SortedDictionary <uint, int> GetKerningPairs(Graphics g, GdiFont font, Dictionary <char, BnoerjGlyph> glyphs, ContentProcessorContext context)
{
// The kerning value is therefore proportional to the em-height.
// To convert it to a real value you must divide the font's absolute
// height in points or pixels by the em-height and then multiply by
// the kerning value.
// GetKerningPairs() returns the converted values.
SortedDictionary <uint, int> kernings = new SortedDictionary <uint, int>();
IntPtr hDC = g.GetHdc();
IntPtr hFont = NativeMethods.Gdi32.SelectObject(hDC, font.ToHfont());
uint pairCount = NativeMethods.Gdi32.GetKerningPairs(hDC, 0, null);
NativeMethods.Gdi32.KERNINGPAIR[] kerningPairs = new NativeMethods.Gdi32.KERNINGPAIR[pairCount];
NativeMethods.Gdi32.GetKerningPairs(hDC, pairCount, kerningPairs);
foreach (NativeMethods.Gdi32.KERNINGPAIR pair in kerningPairs)
{
BnoerjGlyph glyph;
if (pair.iKernAmount != 0 &&
glyphs.TryGetValue((char)pair.wFirst, out glyph) == true &&
glyphs.TryGetValue((char)pair.wSecond, out glyph) == true)
{
uint kerningKey = ((uint)pair.wFirst) << 16 | (uint)pair.wSecond;
kernings.Add(kerningKey, pair.iKernAmount);
}
}
context.Logger.LogMessage("Kerning pairs: using {0} of {1}", kernings.Count, pairCount);
NativeMethods.Gdi32.SelectObject(hDC, hFont);
g.ReleaseHdc(hDC);
return(kernings);
}
public static Size GetTextSize(Graphics graphics, string text, Font font)
{
IntPtr hdc = IntPtr.Zero;
if ( graphics != null )
{
// Get device context from the graphics passed in
hdc = graphics.GetHdc();
}
else
{
// Get screen device context
hdc = WindowsAPI.GetDC(IntPtr.Zero);
}
IntPtr fontHandle = font.ToHfont();
IntPtr currentFontHandle = WindowsAPI.SelectObject(hdc, fontHandle);
Win32.RECT rect = new Win32.RECT();
rect.left = 0;
rect.right = 0;
rect.top = 0;
rect.bottom = 0;
WindowsAPI.DrawText(hdc, text, text.Length, ref rect,
(int)(DrawTextFormatFlags.DT_SINGLELINE | DrawTextFormatFlags.DT_LEFT | DrawTextFormatFlags.DT_CALCRECT));
WindowsAPI.SelectObject(hdc, currentFontHandle);
WindowsAPI.DeleteObject(fontHandle);
if ( graphics != null )
graphics.ReleaseHdc(hdc);
else
WindowsAPI.ReleaseDC(IntPtr.Zero, hdc);
return new Size(rect.right - rect.left, rect.bottom - rect.top);
}
private TEXTMETRIC GenerateTextMetrics(
Graphics graphics,
Font font)
{
IntPtr hDC = IntPtr.Zero;
TEXTMETRIC textMetric;
IntPtr hFont = IntPtr.Zero;
try
{
hDC = graphics.GetHdc();
hFont = font.ToHfont();
IntPtr hFontDefault = SelectObject(hDC, hFont);
bool result = GetTextMetrics(hDC, out textMetric);
SelectObject(hDC, hFontDefault);
}
finally
{
if (hFont != IntPtr.Zero)
{
DeleteObject(hFont);
}
if (hDC != IntPtr.Zero)
{
graphics.ReleaseHdc(hDC);
}
}
return(textMetric);
}
/// <summary>
/// Check if the font has a fixed width
/// </summary>
/// <param name="font">Font to check</param>
/// <returns>true if the font has a fixed width</returns>
public static bool IsFixedPitch(Font font)
{
bool result;
IntPtr fnt = font.ToHfont();
using (Bitmap bmp = new Bitmap(1, 1))
{
using (Graphics g = Graphics.FromImage(bmp))
{
IntPtr hdc = g.GetHdc();
// store the current font and set the new one
IntPtr fntOld = SelectObject(hdc, fnt);
TEXTMETRIC metric = new TEXTMETRIC();
NativeMethods.GetTextMetrics(hdc, ref metric);
result = (metric.tmPitchAndFamily & TMPF_FIXED_PITCH) == 0;
// restore the old font
SelectObject(hdc, fntOld);
g.ReleaseHdc(hdc);
}
}
DeleteObject(fnt);
return result;
}
// Methods
public TextPainter(Control Control)
{
this.oldMode = 1;
this.bufferSize = 0;
this.control = Control;
this.fontTable = new Hashtable();
this.brushTable = new Hashtable();
this.penTable = new Hashtable();
IntPtr ptr1 = Win32.GetDC(IntPtr.Zero);
System.Drawing.Font font1 = new System.Drawing.Font(FontFamily.GenericMonospace, 10f);
try
{
this.measureDC = Win32.CreateCompatibleDC(ptr1);
this.oldMeasureFont = Win32.SelectObject(this.measureDC, font1.ToHfont());
}
finally
{
Win32.ReleaseDC(IntPtr.Zero, ptr1);
}
this.Font = font1;
this.Color = Consts.DefaultControlForeColor;
this.BkColor = Consts.DefaultControlBackColor;
this.PenColor = Consts.DefaultControlForeColor;
this.bkMode = 2;
}
public static List <FontRange> GetUnicodeRangesForFont(this sd.Font font)
{
var g = sd.Graphics.FromHwnd(IntPtr.Zero);
IntPtr hdc = g.GetHdc();
IntPtr hFont = font.ToHfont();
IntPtr old = SelectObject(hdc, hFont);
uint size = GetFontUnicodeRanges(hdc, IntPtr.Zero);
IntPtr glyphSet = Marshal.AllocHGlobal((int)size);
GetFontUnicodeRanges(hdc, glyphSet);
List <FontRange> fontRanges = new List <FontRange>();
int count = Marshal.ReadInt32(glyphSet, 12);
for (int i = 0; i < count; i++)
{
FontRange range = new FontRange();
range.Low = (UInt16)Marshal.ReadInt16(glyphSet, 16 + i * 4);
range.High = (UInt16)(range.Low + Marshal.ReadInt16(glyphSet, 18 + i * 4) - 1);
fontRanges.Add(range);
}
SelectObject(hdc, old);
Marshal.FreeHGlobal(glyphSet);
g.ReleaseHdc(hdc);
g.Dispose();
return(fontRanges);
}
public static Size GetTextSize(Graphics graphics, string text, Font font, ref Rectangle rc, DrawTextFormatFlags drawFlags)
{
IntPtr hdc = IntPtr.Zero;
if ( graphics != null )
{
// Get device context from the graphics passed in
hdc = graphics.GetHdc();
}
else
{
// Get screen device context
hdc = WindowsAPI.GetDC(IntPtr.Zero);
}
IntPtr fontHandle = font.ToHfont();
IntPtr currentFontHandle = WindowsAPI.SelectObject(hdc, fontHandle);
Win32.RECT rect = new Win32.RECT();
rect.left = rc.Left;
rect.right = rc.Right;
rect.top = rc.Top;
rect.bottom = rc.Bottom;
WindowsAPI.DrawText(hdc, text, text.Length, ref rect, (int)drawFlags);
WindowsAPI.SelectObject(hdc, currentFontHandle);
WindowsAPI.DeleteObject(fontHandle);
if ( graphics != null )
graphics.ReleaseHdc(hdc);
else
WindowsAPI.ReleaseDC(IntPtr.Zero, hdc);
return new Size(rect.right - rect.left, rect.bottom - rect.top);
}
/// <summary>
/// Creates a new CodepointRange object for a font.
/// </summary>
public CodepointRange(Font font)
{
List<char> rangeList = new List<char>();
Graphics g = Graphics.FromImage(new Bitmap(1, 1));
IntPtr hdc = g.GetHdc();
IntPtr hFont = font.ToHfont();
IntPtr oldFont = SelectObject(hdc, hFont);
uint size = GetFontUnicodeRanges(hdc, IntPtr.Zero);
IntPtr glyphSet = Marshal.AllocHGlobal((int)size);
GetFontUnicodeRanges(hdc, glyphSet);
codepointCount = Marshal.ReadInt32(glyphSet, 8);
int tmp = 0;
int count = Marshal.ReadInt32(glyphSet, 12);
for (int i = 0; i < count; i++)
{
char firstIncluded = (char)Marshal.ReadInt16(glyphSet, 16 + i * 4);
char firstExcluded = (char)(firstIncluded + Marshal.ReadInt16(glyphSet, 18 + i * 4));
tmp += firstExcluded - firstIncluded;
rangeList.Add(firstIncluded);
rangeList.Add(firstExcluded);
}
SelectObject(hdc, oldFont);
DeleteObject(hFont);
Marshal.FreeHGlobal(glyphSet);
g.ReleaseHdc(hdc);
g.Dispose();
if (tmp != codepointCount) throw new Exception(font.FontFamily.Name);
ranges = rangeList.ToArray();
if (ranges.Length < 2) throw new Exception();
}
public GdiTextureFont(int width, int height, System.Drawing.Font font, PixelFarm.Drawing.FontInfo fontInfo)
{
//if (this.dbugId == 2)
//{
//}
this.width = width;
this.height = height;
this.textureAtlas = new TextureAtlas(width, height);
this.hFont = font.ToHfont();
//32 bits bitmap
textBoardBmp = new System.Drawing.Bitmap(textBoardW, textBoardH, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
gx = System.Drawing.Graphics.FromImage(textBoardBmp);
//draw character map
//basic eng
this.fontInfo = fontInfo;
char[] chars = new char[255];
for (int i = 0; i < 255; ++i)
{
chars[i] = (char)i;
}
//PrepareCharacterMap("ญู".ToCharArray());
PrepareCharacterMapBlackOnWhite(chars);
MakeTransparentOnWhite(textBoardBmp);
//PrepareCharacterMapWhiteOnBlack(chars);
//MakeTransparentOnBlack(textBoardBmp);
//------------------
#if DEBUG
//save bmp for debug
//textBoardBmp.Save("d:\\WImageTest\\font_" + dbugId + ".png");
#endif
//-------------------
}
/// <summary>
/// Measure a multiline string
/// </summary>
public static Size MeasureString(Graphics gr, Font font, string text, int width)
{
if (text == null) return new Size(1, 1);
Rect bounds = new Rect() { Left = 0, Right = width, Bottom = 1, Top = 0 };
IntPtr hDc = gr.GetHdc();
try
{
int flags = DTCALCRECT | DTWORDBREAK;
IntPtr controlFont = font.ToHfont();
IntPtr originalObject = SelectObject(hDc, controlFont);
try
{
DrawText(hDc, text, text.Length, ref bounds, flags);
}
finally
{
SelectObject(hDc, originalObject); // Release resources
}
}
finally
{
gr.ReleaseHdc(hDc);
}
return new Size(bounds.Right - bounds.Left, bounds.Bottom - bounds.Top);
}
/*
* get unicode font ranges
*/
public static List<FontRange> GetFontUnicodeRanges(Font font)
{
Graphics g = Graphics.FromHwnd(IntPtr.Zero);
IntPtr hdc = g.GetHdc();
IntPtr hFont = font.ToHfont();
IntPtr old = SelectObject(hdc, hFont);
uint size = GetFontUnicodeRanges(hdc, IntPtr.Zero);
IntPtr glyphSet = Marshal.AllocHGlobal((int)size);
GetFontUnicodeRanges(hdc, glyphSet);
List<FontRange> fontRanges = new List<FontRange>();
int count = Marshal.ReadInt32(glyphSet, 12);
for (int i = 0; i < count; i++)
{
FontRange range = new FontRange();
range.Low = (UInt16)Marshal.ReadInt16(glyphSet, 16 + i * 4);
range.High = (UInt16)(range.Low + Marshal.ReadInt16(glyphSet, 18 + i * 4) - 1);
fontRanges.Add(range);
}
SelectObject(hdc, old);
Marshal.FreeHGlobal(glyphSet);
g.ReleaseHdc(hdc);
g.Dispose();
return fontRanges;
}
public static Size GetTextSize(Graphics graphics, string text, Font font)
{
IntPtr hdc = IntPtr.Zero;
if ( graphics != null )
{
// Get device context from the graphics passed in
hdc = graphics.GetHdc();
}
else
{
// Get screen device context
hdc = APIsGdi.GetDC(IntPtr.Zero);
}
IntPtr fontHandle = font.ToHfont();
IntPtr currentFontHandle = APIsGdi.SelectObject(hdc, fontHandle);
APIsStructs.RECT rect = new APIsStructs.RECT();
rect.left = 0;
rect.right = 0;
rect.top = 0;
rect.bottom = 0;
APIsUser32.DrawText(hdc, text, text.Length, ref rect,
APIsEnums.DrawTextFormatFlags.SINGLELINE | APIsEnums.DrawTextFormatFlags.LEFT | APIsEnums.DrawTextFormatFlags.CALCRECT);
APIsGdi.SelectObject(hdc, currentFontHandle);
APIsGdi.DeleteObject(fontHandle);
if(graphics != null)
graphics.ReleaseHdc(hdc);
else
APIsUser32.ReleaseDC(IntPtr.Zero, hdc);
return new Size(rect.right - rect.left, rect.bottom - rect.top);
}
public void DrawText(string text, Point point, Font font, Color foreColor)
{
IntPtr fontHandle = font.ToHfont();
IntPtr oldFontHandle = NativeMethods.SelectObject(this.graphicsHandle, fontHandle);
int oldBkMode = NativeMethods.SetBkMode(this.graphicsHandle, NativeMethods.TRANSPARENT);
int oldTextColor = NativeMethods.SetTextColor(this.graphicsHandle, Color.FromArgb(0, foreColor.R, foreColor.G, foreColor.B).ToArgb());
Size size = this.MeassureTextInternal(text);
NativeMethods.RECT clip = new NativeMethods.RECT();
clip.left = point.X;
clip.top = point.Y;
clip.right = clip.left + size.Width;
clip.bottom = clip.top + size.Height;
// ExtTextOut does not show Mnemonics highlighting.
NativeMethods.DrawText(this.graphicsHandle, text, text.Length, ref clip, NativeMethods.DT_SINGLELINE | NativeMethods.DT_LEFT);
NativeMethods.SetTextColor(this.graphicsHandle, oldTextColor);
NativeMethods.SetBkMode(this.graphicsHandle, oldBkMode);
NativeMethods.SelectObject(this.graphicsHandle, oldFontHandle);
NativeMethods.DeleteObject(fontHandle);
}
Win32.TEXTMETRIC GetTextMetrics(Font f)
{
Win32.TEXTMETRIC t;
IntPtr hdc = Win32.GetDC(Handle);
Win32.SelectObject(hdc, f.ToHfont());
Win32.GetTextMetrics(hdc, out t);
return t;
}
public KerningHelper( Font font )
{
dc = CreateCompatibleDC( IntPtr.Zero );
if( dc == IntPtr.Zero )
throw new System.ComponentModel.Win32Exception();
hFont = font.ToHfont();
oldFont = SelectObject( dc, hFont );
}
/// <summary>
/// Get pointer to unmanaged Hfont object for the given managed font object.
/// </summary>
/// <param name="font">the font to get unmanaged font for</param>
/// <returns>Hfont pointer</returns>
public static IntPtr GetCachedHFont(System.Drawing.Font font)
{
IntPtr hFont;
if (!_fontsUnmanagedCache.TryGetValue(font, out hFont))
{
_fontsUnmanagedCache[font] = hFont = font.ToHfont();
}
return(hFont);
}
public Font(string filename, int size, FontStyle style)
{
// Debug.Assert(false);
string fontname = filename.Replace("/Application/", "./");
this.__size = size;
this.__style = style;
System.Drawing.FontStyle _style = System.Drawing.FontStyle.Regular;
switch (style)
{
case FontStyle.Regular:
_style = System.Drawing.FontStyle.Regular;
break;
case FontStyle.Bold:
_style = System.Drawing.FontStyle.Bold;
break;
case FontStyle.Italic:
_style = System.Drawing.FontStyle.Italic;
break;
}
PrivateFontCollection privateFonts = new PrivateFontCollection();
privateFonts.AddFontFile(fontname);
//Arial
//Comic Sans MS
//MS Gothic
this.__font = new System.Drawing.Font(privateFonts.Families[0], (int)(__size * 0.75f), _style); //FIXME:???0.8
//this.__font = new System.Drawing.Font("Arial", __size, _style); //FIXME:???0.8
//this.__font = new System.Drawing.Font(/*"宋体"*/FontFamily.GenericSansSerif, __size, _style);
this.__metrics = new FontMetrics();
IntPtr hdc = GetDC(IntPtr.Zero);
IntPtr handle = __font.ToHfont();
try
{
IntPtr handle2 = SelectObject(hdc, handle);
TEXTMETRIC tEXTMETRIC = new TEXTMETRIC();
GetTextMetrics(hdc, ref tEXTMETRIC);
__metrics.Ascent = tEXTMETRIC.tmAscent;
__metrics.Descent = tEXTMETRIC.tmDescent;
__metrics.Leading = tEXTMETRIC.tmHeight - tEXTMETRIC.tmAscent - tEXTMETRIC.tmDescent;
SelectObject(hdc, handle2);
}
finally
{
DeleteObject(handle);
ReleaseDC(IntPtr.Zero, hdc);
}
}
static byte[] ReadFontBytesFromGdi(GdiFont gdiFont)
{
// Weird: LastError is always 123 or 127. Comment out Debug.Assert.
int error = Marshal.GetLastWin32Error();
//Debug.Assert(error == 0);
error = Marshal.GetLastWin32Error();
//Debug.Assert(error == 0);
IntPtr hfont = gdiFont.ToHfont();
IntPtr hdc = NativeMethods.GetDC(IntPtr.Zero);
error = Marshal.GetLastWin32Error();
//Debug.Assert(error == 0);
IntPtr oldFont = NativeMethods.SelectObject(hdc, hfont);
error = Marshal.GetLastWin32Error();
//Debug.Assert(error == 0);
// Get size of the font file.
bool isTtcf = false;
// In Azure I get 0xc0000022
int size = NativeMethods.GetFontData(hdc, 0, 0, null, 0);
// Check for ntstatus.h: #define STATUS_ACCESS_DENIED ((NTSTATUS)0xC0000022L)
if ((uint)size == 0xc0000022)
{
throw new InvalidOperationException("Microsoft Azure returns STATUS_ACCESS_DENIED ((NTSTATUS)0xC0000022L) from GetFontData. This is a bug in Azure. You must implement a FontResolver to circumvent this issue.");
}
if (size == NativeMethods.GDI_ERROR)
{
// Assume that the font file is a true type collection.
size = NativeMethods.GetFontData(hdc, ttcf, 0, null, 0);
isTtcf = true;
}
error = Marshal.GetLastWin32Error();
//Debug.Assert(error == 0);
if (size == 0)
{
throw new InvalidOperationException("Cannot retrieve font data.");
}
byte[] bytes = new byte[size];
int effectiveSize = NativeMethods.GetFontData(hdc, isTtcf ? ttcf : 0, 0, bytes, size);
Debug.Assert(size == effectiveSize);
// Clean up.
NativeMethods.SelectObject(hdc, oldFont);
NativeMethods.ReleaseDC(IntPtr.Zero, hdc);
return(bytes);
}
public static void DrawText(Graphics graphics, string text, Font font, Rectangle bounds, Color color, TextFormatFlags flags, TextStyle textStyle)
{
if (!VisualStyleRenderer.IsSupported) {
TextRenderer.DrawText(graphics, text, font, bounds, color, flags);
return;
}
IntPtr primaryHdc = graphics.GetHdc();
// Create a memory DC so we can work offscreen
IntPtr memoryHdc = CreateCompatibleDC(primaryHdc);
// Create a device-independent bitmap and select it into our DC
BITMAPINFO info = new BITMAPINFO();
info.biSize = Marshal.SizeOf(info);
info.biWidth = bounds.Width;
info.biHeight = -bounds.Height;
info.biPlanes = 1;
info.biBitCount = 32;
info.biCompression = 0; // BI_RGB
IntPtr dib = CreateDIBSection(primaryHdc, info, 0, 0, IntPtr.Zero, 0);
SelectObject(memoryHdc, dib);
// Create and select font
IntPtr fontHandle = font.ToHfont();
SelectObject(memoryHdc, fontHandle);
// Draw glowing text
VisualStyleRenderer renderer = new VisualStyleRenderer(System.Windows.Forms.VisualStyles.VisualStyleElement.Window.Caption.Active);
DTTOPTS dttOpts = new DTTOPTS();
dttOpts.dwSize = Marshal.SizeOf(typeof(DTTOPTS));
if (textStyle == TextStyle.Glowing) {
dttOpts.dwFlags = DTT_COMPOSITED | DTT_GLOWSIZE | DTT_TEXTCOLOR;
}
else {
dttOpts.dwFlags = DTT_COMPOSITED | DTT_TEXTCOLOR;
}
dttOpts.crText = ColorTranslator.ToWin32(color);
dttOpts.iGlowSize = 8; // This is about the size Microsoft Word 2007 uses
RECT textBounds = new RECT(0, 0, bounds.Right - bounds.Left, bounds.Bottom - bounds.Top);
DrawThemeTextEx(renderer.Handle, memoryHdc, 0, 0, text, -1, (int)flags, ref textBounds, ref dttOpts);
// Copy to foreground
const int SRCCOPY = 0x00CC0020;
BitBlt(primaryHdc, bounds.Left, bounds.Top, bounds.Width, bounds.Height, memoryHdc, 0, 0, SRCCOPY);
// Clean up
DeleteObject(fontHandle);
DeleteObject(dib);
DeleteDC(memoryHdc);
graphics.ReleaseHdc(primaryHdc);
}
PixelFarm.Drawing.FontInfo RegisterFont(System.Drawing.Font newFont, FontKey fontKey)
{
//from ...
//1. http://msdn.microsoft.com/en-us/library/xwf9s90b%28v=vs.100%29.aspx
//3. Font metrics from http://msdn.microsoft.com/en-us/library/xwf9s90b(VS.71).aspx
//2. http://stackoverflow.com/questions/1006069/how-do-i-get-the-position-of-the-text-baseline-in-a-label-and-a-numericupdown
//cellHeight = font's ascent + descent
//linespacing = cellHeight + external leading
//em height (size)= cellHeight - internal leading
//-------------------
//evaluate this font, collect font matrix in pixel mode
PixelFarm.Drawing.FontInfo fontInfo;
if (!_fontInfoCache.TryGetValue(newFont, out fontInfo))
{
System.Drawing.FontFamily ff = newFont.FontFamily;
int lineSpacing = ff.GetLineSpacing(newFont.Style);
//font height is expensive call ****
int fontHeight = newFont.Height;
//convert descent
float fontSize = newFont.Size;
int fontEmHeight = newFont.FontFamily.GetEmHeight(newFont.Style);
int fontAscent = newFont.FontFamily.GetCellAscent(newFont.Style);
float descent = newFont.FontFamily.GetCellDescent(newFont.Style);
var myFont = new PixelFarm.Drawing.WinGdi.MyFont(newFont);
fontInfo = new PixelFarm.Drawing.WinGdi.MyFontInfo(
myFont,
fontHeight,
(fontAscent * fontSize / fontEmHeight),
(descent * fontSize / fontEmHeight),
fontHeight * fontAscent / lineSpacing,
gdiFontHelper);
myFont.SetFontInfo(fontInfo);
//lineSpacing * newFont.FontFamily.GetCellAscent(newFont.Style) / linespace);
//1. info
_fontInfoCache.Add(newFont, fontInfo);
_fontInfoCacheByFontKey.Add(fontKey, fontInfo);
_fontsUnmanagedCache[newFont] = newFont.ToHfont();
//2. line cache
_fontHeightCache[newFont] = fontHeight;
return(fontInfo);
}
return(fontInfo);
}
public Size MeasureText(string text, Font font)
{
IntPtr fontHandle = font.ToHfont();
IntPtr oldFontHandle = NativeMethods.SelectObject(this.graphicsHandle, fontHandle);
Size size = this.MeassureTextInternal(text);
NativeMethods.SelectObject(this.graphicsHandle, oldFontHandle);
NativeMethods.DeleteObject(fontHandle);
return size;
}
public static TEXTMETRICW GetTextMetrics(this sd.Font font)
{
using (var graphics = new swf.Control().CreateGraphics())
{
var hDC = graphics.GetHdc();
var hFont = font.ToHfont();
var hFontDefault = SelectObject(hDC, hFont);
GetTextMetrics(hDC, out var textMetric);
return(textMetric);
}
}
public ChartDraw()
{
IntPtr dC = Win32.GetDC(IntPtr.Zero);
System.Drawing.Font font = new System.Drawing.Font(FontFamily.GenericMonospace, 10f);
try {
this.measureDC = Win32.CreateCompatibleDC(dC);
this.measureHFont = font.ToHfont();
this.oldMeasureFont = Win32.SelectObject(this.measureDC, this.measureHFont);
} finally {
Win32.ReleaseDC(IntPtr.Zero, dC);
}
this.Init();
}
public static void DrawString(Control context, Font font, string text, Rectangle textBounds, bool useMnemonics, GdiTextDrawMode textMode)
{
IntPtr hdc = User32.GetDC(context.Handle);
try
{
Gdi32.SetBkColor(hdc, Gdi32.ToColorRef(context.BackColor));
Gdi32.SetTextColor(hdc, Gdi32.ToColorRef(context.ForeColor));
try
{
IntPtr hFont = font.ToHfont();
try
{
IntPtr hPrevFont = Gdi32.SelectObject(hdc, hFont);
try
{
StringBuilder sb = new StringBuilder(text);
RECT rect = textBounds;
User32.DRAWTEXTPARAMS dtparams = new User32.DRAWTEXTPARAMS();
dtparams.cbSize = (uint)Marshal.SizeOf(typeof(User32.DRAWTEXTPARAMS));
User32.DT flags =
textMode == GdiTextDrawMode.EndEllipsis ? User32.DT.END_ELLIPSIS
: textMode == GdiTextDrawMode.WordBreak ? User32.DT.WORDBREAK | User32.DT.END_ELLIPSIS
: User32.DT.WORDBREAK;
if (useMnemonics)
flags |= User32.DT.NOPREFIX;
if (0 == User32.DrawTextEx(hdc, sb, sb.Length, ref rect, flags, ref dtparams))
throw new Win32Exception(Marshal.GetLastWin32Error());
}
finally
{
Gdi32.SelectObject(hdc, hPrevFont);
}
}
finally
{
Gdi32.DeleteObject(hFont);
}
}
finally
{
}
}
finally
{
User32.ReleaseDC(context.Handle, hdc);
}
}
public static bool ScriptPlace(System.Drawing.Font font, Uniscribe.SCRIPT_ITEM[] items,
List <ushort[]> pwGlyphs, List <int> cGlyphs, List <Uniscribe.SCRIPT_VISATTR[]> psva,
out List <int[]> piAdvanceArray, out List <Uniscribe.GOFFSET[]> pGoffsetArray, out List <Uniscribe.ABC> pABCArray)
{
piAdvanceArray = new List <int[]>();
pGoffsetArray = new List <Uniscribe.GOFFSET[]>();
pABCArray = new List <Uniscribe.ABC>();
if (font == null)
{
return(false);
}
bool res = false;
// HFONT hfont = initialize your font;
IntPtr hfont = font.ToHfont();
IntPtr psc = IntPtr.Zero; // Initialize to NULL, will be filled lazily.
// Don't use the last item because it is a dummy that points
// to the end of the string.
for (int i = 0; i < items.Length - 1; i++)
{
int[] piAdvance;
Uniscribe.GOFFSET[] pGoffset;
Uniscribe.ABC pABC;
Uniscribe.SCRIPT_ANALYSIS sa = items[i].a;
res = callScriptPlaceForItem(ref hfont, ref psc, pwGlyphs[i], cGlyphs[i], psva[i], ref sa, out piAdvance, out pGoffset, out pABC);
if (res)
{
items[i].a = sa;
piAdvanceArray.Add(piAdvance);
pGoffsetArray.Add(pGoffset);
pABCArray.Add(pABC);
}
}
// Need to tell Uniscribe to delete the cache we were using. If you are going
// to keep the HFONT around, you should probably also keep the cache.
// ScriptFreeCache(psc);
Win32.DeleteObject(hfont);
return(res);
}
private void vAdjustFontSize(System.Drawing.Font fntFonte)
{
PS = new struct0E();
PS.QR = 212;
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1, 1);
System.Drawing.Graphics graph = System.Drawing.Graphics.FromImage(bmp);
float fUnit = (72000f / graph.DpiX);
System.Drawing.Font fntUnit = new System.Drawing.Font(fntFonte.Name, fUnit, fntFonte.Style, System.Drawing.GraphicsUnit.Point);
System.IntPtr ptr1 = graph.GetHdc();
System.IntPtr ptr2 = fntUnit.ToHfont();
System.IntPtr ptr3 = SelectObject(ptr1, ptr2);
if (GetOutlineTextMetrics(ptr1, 212, ref PS) != 0)
{
ARIAL_W_ARRAY = new int[((uint)((PS.QS.Q5 - PS.QS.Q4) + 1))];
if (System.Environment.OSVersion.Platform >= PlatformID.Win32NT)
{
GetCharWidth32(ptr1, PS.QS.Q4, PS.QS.Q5, ARIAL_W_ARRAY);
}
else
{
System.Drawing.Size size1 = System.Drawing.Size.Empty;
System.Text.StringBuilder strbMeasure = new System.Text.StringBuilder();
for (int num1 = 0; (num1 < ARIAL_W_ARRAY.Length); num1 += 1)
{
strbMeasure.Length = 0;
strbMeasure.Append(((char)(PS.QS.Q4 + num1)));
GetTextExtentPoint32(ptr1, strbMeasure.ToString(), 1, ref size1);
ARIAL_W_ARRAY[num1] = size1.Width;
}
}
}
bool flag1 = ((PS.QW & 1) == 0);
if (flag1)
{
int num2 = GetFontData(ptr1, 0, 0, null, 0);
//this.PQ = new byte[((uint) num2)];
//GetFontData(ptr1, 0, 0, this.PQ, num2);
//this.PR = new Y(this);
}
SelectObject(ptr1, ptr3);
DeleteObject(ptr2);
graph.ReleaseHdc(ptr1);
fntUnit.Dispose();
graph.Dispose();
bmp.Dispose();
}
public Font(FontAlias alias, int size, FontStyle style)
{
this.__alias = alias;
this.__size = size;
this.__style = style;
System.Drawing.FontStyle _style = System.Drawing.FontStyle.Regular;
switch (style)
{
case FontStyle.Regular:
_style = System.Drawing.FontStyle.Regular;
break;
case FontStyle.Bold:
_style = System.Drawing.FontStyle.Bold;
break;
case FontStyle.Italic:
_style = System.Drawing.FontStyle.Italic;
break;
}
//Arial
//Comic Sans MS
//MS Gothic
this.__font = new System.Drawing.Font("MS Gothic", (int)(__size * 0.75f), _style); //FIXME:???0.8
//this.__font = new System.Drawing.Font("Arial", __size, _style); //FIXME:???0.8
//this.__font = new System.Drawing.Font(/*"宋体"*/FontFamily.GenericSansSerif, __size, _style);
this.__metrics = new FontMetrics();
IntPtr hdc = GetDC(IntPtr.Zero);
IntPtr handle = __font.ToHfont();
try
{
IntPtr handle2 = SelectObject(hdc, handle);
TEXTMETRIC tEXTMETRIC = new TEXTMETRIC();
GetTextMetrics(hdc, ref tEXTMETRIC);
__metrics.Ascent = tEXTMETRIC.tmAscent;
__metrics.Descent = tEXTMETRIC.tmDescent;
__metrics.Leading = tEXTMETRIC.tmHeight - tEXTMETRIC.tmAscent - tEXTMETRIC.tmDescent;
SelectObject(hdc, handle2);
}
finally
{
DeleteObject(handle);
ReleaseDC(IntPtr.Zero, hdc);
}
}
public static bool ScriptShape(string str, System.Drawing.Font font, Uniscribe.SCRIPT_ITEM[] items,
out List <ushort[]> pwOutGlyphsArray, out List <int> cGlyphsArray, out List <Uniscribe.SCRIPT_VISATTR[]> psvaArray)
{
pwOutGlyphsArray = new List <ushort[]>();
cGlyphsArray = new List <int>();
psvaArray = new List <Uniscribe.SCRIPT_VISATTR[]>();
if (font == null)
{
return(false);
}
bool res = false;
// HFONT hfont = initialize your font;
IntPtr hfont = font.ToHfont();
IntPtr psc = IntPtr.Zero; // Initialize to NULL, will be filled lazily.
// Don't use the last item because it is a dummy that points
// to the end of the string.
for (int i = 0; i < items.Length - 1; i++)
{
ushort[] pwOutGlyphs;
ushort[] pwLogClust;
Uniscribe.SCRIPT_VISATTR[] psva;
int length = items[i + 1].iCharPos - items[i].iCharPos; // Length of this run.
string run = str.Substring(items[i].iCharPos, length); // Beginning of this run.
res = callScriptShapeForItem(run, length, ref hfont, ref psc, items[i].a, out pwOutGlyphs, out pwLogClust, out psva);
if (res)
{
pwOutGlyphsArray.Add(pwOutGlyphs);
cGlyphsArray.Add(pwOutGlyphs.Length);
psvaArray.Add(psva);
}
}
// Need to tell Uniscribe to delete the cache we were using. If you are going
// to keep the HFONT around, you should probably also keep the cache.
// ScriptFreeCache(psc);
Win32.DeleteObject(hfont);
return(res);
}
public static Size GetTextSize( Graphics g, string text, Font font )
{
IntPtr hdc = GetGraphicsHDC( g );
IntPtr hFont = font.ToHfont();
IntPtr hOldFont = WindowsAPI.SelectObject( hdc, hFont );
RECT rect = new RECT();
WindowsAPI.DrawText( hdc, text, text.Length, ref rect, DEF_TEXTFORMAT );
WindowsAPI.SelectObject( hdc, hOldFont );
WindowsAPI.DeleteObject( hFont );
ReleaseGraphicHDC( g, hdc );
return ( Size )rect;
}
/// <summary>
/// Measure a multiline string
/// </summary>
public static Size MeasureString(Graphics gr, Font font, string text, int width)
{
try{
Rect bounds = new Rect() { Left = 0, Right = width, Bottom = 1, Top = 0 };
IntPtr hDc = gr.GetHdc();
int flags = DTCALCRECT | DTWORDBREAK;
IntPtr controlFont = font.ToHfont();
IntPtr originalObject = SelectObject(hDc, controlFont);
DrawText(hDc, text, text.Length, ref bounds, flags);
SelectObject(hDc, originalObject); // Release resources
gr.ReleaseHdc(hDc);
return new Size(bounds.Right - bounds.Left, bounds.Bottom - bounds.Top);
}catch(Exception){
return Size.Empty;
}
}
public Font(Document doc, string fontName, System.Drawing.Font winFont)
: base(doc)
{
_fontName = fontName;
//TBD - I have no idea why 720 seems to work. I don't understand the relationship
// between windows font coordinates and PDF glyph coordinates. It seems like this
// should be 1000, but that doesn't work.
System.Drawing.Font f = new System.Drawing.Font(winFont.FontFamily, 720, winFont.Style, GraphicsUnit.Point);
IntPtr hDC = WinGdi.GetDC(IntPtr.Zero); //Screen DC
IntPtr hObjOld = WinGdi.SelectObject(hDC, f.ToHfont());
uint cbSize = WinGdi.GetOutlineTextMetrics(hDC, 0, IntPtr.Zero);
if (cbSize == 0)
{
throw new Exception();
}
StringBuilder sb = new StringBuilder(50);
WinGdi.GetTextFace(hDC, 50, sb);
IntPtr buffer = Marshal.AllocHGlobal((int)cbSize);
try
{
if (WinGdi.GetOutlineTextMetrics(hDC, cbSize, buffer) != 0)
{
_otm = (WinGdi.OUTLINETEXTMETRIC)Marshal.PtrToStructure(buffer, typeof(WinGdi.OUTLINETEXTMETRIC));
_faceName = Marshal.PtrToStringAnsi((IntPtr)((long)buffer + _otm.pFaceName));
_faceName = _faceName.Replace(" ", "-");
_otm.EMSquare = (uint)(_otm.EMSquare / winFont.SizeInPoints);
}
}
finally
{
Marshal.FreeHGlobal(buffer);
}
_fw = new FontWidths(doc, hDC, _otm);
_fd = new FontDescriptor(doc, _faceName, _otm);
WinGdi.SelectObject(hDC, hObjOld);
WinGdi.ReleaseDC(IntPtr.Zero, hDC);
}
public static TEXTMETRIC GetTextMetrics(Graphics graphics, Font font)
{
TEXTMETRIC textmetric;
IntPtr hdc = graphics.GetHdc();
IntPtr hgdiobj = font.ToHfont();
try
{
IntPtr ptr3 = SelectObject(hdc, hgdiobj);
bool textMetrics = GetTextMetrics(hdc, out textmetric);
SelectObject(hdc, ptr3);
}
finally
{
DeleteObject(hgdiobj);
graphics.ReleaseHdc(hdc);
}
return textmetric;
}
/// <summary>
/// ��ȡָ���ַ���ָ�������µ�����
/// </summary>
/// <param name="uChar">�ַ�</param>
/// <param name="font">����</param>
/// <returns></returns>
public static String GetOutline(uint uChar, Font font)
{
//����
Graphics g = Graphics.FromHwnd(IntPtr.Zero);
IntPtr hdc = g.GetHdc();
//������ѡ�볡��
IntPtr fontPtr = font.ToHfont();
GdiNativeMethods.SelectObject(hdc, fontPtr);
try
{
return GetOutline(hdc, uChar);
}
catch (Exception e)
{
Console.Write(e.Message);
return "";
}
}
bool CheckFontForEmbedding(Graphics g, GdiFont font, ContentProcessorContext context)
{
bool embeddingAllowed = false;
IntPtr hDC = g.GetHdc();
IntPtr hFont = NativeMethods.Gdi32.SelectObject(hDC, font.ToHfont());
uint cbSize = NativeMethods.Gdi32.GetOutlineTextMetrics(hDC, 0, IntPtr.Zero);
if (cbSize == 0)
{
return(embeddingAllowed);
}
IntPtr buffer = Marshal.AllocHGlobal((int)cbSize);
try
{
if (NativeMethods.Gdi32.GetOutlineTextMetrics(hDC, cbSize, buffer) != 0)
{
NativeMethods.Gdi32.OUTLINETEXTMETRIC otm;
otm = (NativeMethods.Gdi32.OUTLINETEXTMETRIC)Marshal.PtrToStructure(buffer, typeof(NativeMethods.Gdi32.OUTLINETEXTMETRIC));
FontEmbeddingFlags fontEmbedding = (FontEmbeddingFlags)otm.otmfsType;
embeddingAllowed =
(fontEmbedding == FontEmbeddingFlags.Installable) ||
((fontEmbedding & FontEmbeddingFlags.NotAllowed) == 0 &&
(fontEmbedding & FontEmbeddingFlags.Editable) != 0 ||
(fontEmbedding & FontEmbeddingFlags.BitmapOnly) != 0);
context.Logger.LogMessage("Embedding font {0} is {1} as {2}", font.Name, embeddingAllowed ? "allowed" : "not allowed", fontEmbedding.ToString());
context.Logger.LogMessage("Avg. width: {0}, Max. width: {1}", otm.otmTextMetrics.tmAveCharWidth, otm.otmTextMetrics.tmMaxCharWidth);
}
}
finally
{
Marshal.FreeHGlobal(buffer);
}
NativeMethods.Gdi32.SelectObject(hDC, hFont);
g.ReleaseHdc(hDC);
return(embeddingAllowed);
}
public static TEXTMETRIC GetTextMetrics( Graphics graphics, Font font )
{
IntPtr hDC = graphics.GetHdc();
TEXTMETRIC textMetric;
IntPtr hFont = font.ToHfont();
try
{
IntPtr hFontPreviouse = SelectObject(hDC, hFont);
bool result = GetTextMetrics(hDC, out textMetric);
SelectObject(hDC, hFontPreviouse);
}
finally
{
DeleteObject(hFont);
graphics.ReleaseHdc(hDC);
}
return textMetric;
}
/// <summary>
/// ��ȡָ���ַ���ָ�������µ�����
/// </summary>
/// <param name="uChar">�ַ�</param>
/// <param name="font">����</param>
/// <returns></returns>
public static DOutline GetOutline(uint uChar, Font font)
{
//����
Graphics g = Graphics.FromHwnd(IntPtr.Zero);
IntPtr hdc = g.GetHdc();
//������ѡ�볡��
IntPtr fontPtr = font.ToHfont();
GdiNativeMethods.SelectObject(hdc, fontPtr);
try
{
return GetOutline(hdc, uChar);
}
finally
{
//�ر����������ͷų���
GdiNativeMethods.CloseHandle(fontPtr);
g.ReleaseHdc(hdc);
}
}
public static Size GetTextSize(Graphics graphics, string text, Font font)
{
IntPtr hdc = graphics.GetHdc();
IntPtr fontHandle = font.ToHfont();
IntPtr currentFontHandle = WindowsAPI.SelectObject(hdc, fontHandle);
RECT rect = new RECT();
rect.left = 0;
rect.right = 0;
rect.top = 0;
rect.bottom = 0;
WindowsAPI.DrawText(hdc, text, text.Length, ref rect,
(int)(DrawTextFormatFlags.DT_SINGLELINE | DrawTextFormatFlags.DT_LEFT | DrawTextFormatFlags.DT_CALCRECT));
WindowsAPI.SelectObject(hdc, currentFontHandle);
WindowsAPI.DeleteObject(fontHandle);
graphics.ReleaseHdc(hdc);
return new Size(rect.right - rect.left, rect.bottom - rect.top);
}
public static Size GetTextSize( Graphics g, string text, Font font, ref Rectangle rc, DrawTextFormatFlags drawFlags )
{
IntPtr hdc = GetGraphicsHDC( g );
IntPtr hFont = font.ToHfont();
IntPtr hOldFont = WindowsAPI.SelectObject( hdc, hFont );
Win32.RECT rect = new Win32.RECT();
rect.left = rc.Left;
rect.right = rc.Right;
rect.top = rc.Top;
rect.bottom = rc.Bottom;
WindowsAPI.DrawText( hdc, text, text.Length, ref rect, (int)drawFlags );
WindowsAPI.SelectObject( hdc, hOldFont );
WindowsAPI.DeleteObject( hFont );
ReleaseGraphicHDC( g, hdc );
return ( Size )rect;
}
public static void DrawText(Graphics graphics, string text, Font font, Rectangle rect)
{
IntPtr hdc = graphics.GetHdc();
IntPtr fontHandle = font.ToHfont();
IntPtr currentFontHandle = WindowsAPI.SelectObject(hdc, fontHandle);
WindowsAPI.SetBkMode(hdc, BackgroundMode.TRANSPARENT);
RECT rc = new RECT();
rc.left = rect.Left;
rc.top = rect.Top;
rc.right = rc.left + rect.Width;
rc.bottom = rc.top + rect.Height;
WindowsAPI.DrawText(hdc, text, text.Length, ref rc,
(int) (DrawTextFormatFlags.DT_SINGLELINE | DrawTextFormatFlags.DT_LEFT
| DrawTextFormatFlags.DT_MODIFYSTRING | DrawTextFormatFlags.DT_WORD_ELLIPSIS));
WindowsAPI.SelectObject(hdc, currentFontHandle);
WindowsAPI.DeleteObject(fontHandle);
graphics.ReleaseHdc(hdc);
}
public ScriptMetrics SelectFont(Font font)
{
if (currentFont != font)
{
NativeMethods.SelectObject(HDC, font.ToHfont());
currentFont = font;
currentScriptMetrics = scriptMetricsCache[currentFont];
if (!currentScriptMetrics.HaveMetrics)
{
TEXTMETRIC textMetric;
NativeMethods.GetTextMetrics(HDC, out textMetric);
currentScriptMetrics.Height = textMetric.tmHeight;
currentScriptMetrics.Descent = textMetric.tmDescent;
currentScriptMetrics.HaveMetrics = true;
}
}
return currentScriptMetrics;
}
// Calculate ABC spacing
// http://msdn.microsoft.com/en-us/library/windows/desktop/dd162454(v=vs.85).aspx
private static ABCSpacing CalculateABCSpacing(char character, Font font, Graphics stagingGraphics)
{
var hdc = stagingGraphics.GetHdc();
try
{
var hFont = font.ToHfont();
try
{
var oldFont = GDI.SelectObject(hdc, hFont);
try
{
var abcSpacing = new ABCSpacing[1];
var result = GDI.GetCharABCWidthsFloat(hdc, character, character, abcSpacing);
if (!result)
{
throw new Exception("GetCharABCWidthsFloat failed!");
}
return abcSpacing[0];
}
finally
{
GDI.SelectObject(hdc, oldFont);
}
}
finally
{
GDI.DeleteObject(hFont);
}
}
finally
{
stagingGraphics.ReleaseHdc(hdc);
}
}
public static Rectangle MeasureString(Control context, Font font, string text, Rectangle textBounds)
{
IntPtr hdc = User32.GetDC(context.Handle);
try
{
IntPtr hFont = font.ToHfont();
try
{
IntPtr hPrevFont = Gdi32.SelectObject(hdc, hFont);
try
{
StringBuilder sb = new StringBuilder(text);
RECT rect = textBounds;
rect.bottom = rect.top; // set height to 0
User32.DRAWTEXTPARAMS dtparams = new User32.DRAWTEXTPARAMS();
dtparams.cbSize = (uint)Marshal.SizeOf(typeof(User32.DRAWTEXTPARAMS));
if (0 == User32.DrawTextEx(hdc, sb, sb.Length, ref rect, User32.DT.CALCRECT | User32.DT.WORDBREAK | User32.DT.END_ELLIPSIS, ref dtparams))
throw new Win32Exception(Marshal.GetLastWin32Error());
return rect;
}
finally
{
Gdi32.SelectObject(hdc, hPrevFont);
}
}
finally
{
Gdi32.DeleteObject(hFont);
}
}
finally
{
User32.ReleaseDC(context.Handle, hdc);
}
}
public static bool ScriptTextOut(string filePathSave, System.Drawing.Font font, List <int> xArray, List <int> yArray, uint fuOptions, Win32.RECT lprc,
List <Uniscribe.SCRIPT_ANALYSIS> psaArray, string pwcReserved, int iReserved,
List <ushort[]> pwGlyphsArray, List <int> cGlyphsArray,
List <int[]> piAdvanceArray, List <int[]> piJustifyArray, List <Uniscribe.GOFFSET[]> pGoffsetArray)
{
bool res = false;
int width = 500;
int height = 400;
System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, width, height);
lprc = new Win32.RECT(rect);
Bitmap bitmap = null;
Graphics gr = null;
IntPtr HDC = IntPtr.Zero;
createBitmap(font, ref bitmap, width, height, ref gr);
HDC = gr.GetHdc();
// HFONT hfont = initialize your font;
IntPtr hfont = font.ToHfont();
// HFONT old_font = NULL;
IntPtr old_font = IntPtr.Zero;
// ... select font into hdc ...
old_font = Win32.SelectObject(HDC, hfont);
int old_color = 0;
old_color = Win32.SetTextColor(HDC, ColorTranslator.ToWin32(System.Drawing.Color.Black));
System.Drawing.Color color = ColorTranslator.FromWin32(old_color);
old_color = Win32.SetBkColor(HDC, ColorTranslator.ToWin32(System.Drawing.Color.Yellow));
color = ColorTranslator.FromWin32(old_color);
string text = "It's me!";
Win32.RECT bounds = new Win32.RECT(rect);
int flags = Win32.DT_CENTER | Win32.DT_VCENTER | Win32.DT_SINGLELINE;
uint result = 0;
result = Win32.DrawText(HDC, text, text.Length, ref bounds, flags);
IntPtr psc = IntPtr.Zero; // Initialize to NULL, will be filled lazily.
for (int i = 0; i < psaArray.Count; i++)
{
res = callScriptTextOutForItem(HDC, psc, xArray[i], yArray[i], fuOptions, lprc, psaArray[i], pwcReserved,
iReserved, pwGlyphsArray[i], cGlyphsArray[i], piAdvanceArray[i], piJustifyArray[i], pGoffsetArray[i]);
if (!res)
{
}
}
if (old_font != IntPtr.Zero)
{
Win32.SelectObject(HDC, old_font); // Put back the previous font.
}
gr.ReleaseHdc(HDC);
saveBitmap(bitmap, gr, filePathSave);
return(res);
}
public void DrawTextOnGlass(IntPtr hwnd, String text, Font font, Rectangle ctlrct, int iglowSize)
{
if (IsCompositionEnabled())
{
RECT rc = new RECT();
RECT rc2 = new RECT();
rc.left = ctlrct.Left;
rc.right = ctlrct.Right + 2 * iglowSize; //make it larger to contain the glow effect
rc.top = ctlrct.Top;
rc.bottom = ctlrct.Bottom + 2 * iglowSize;
//Just the same rect with rc,but (0,0) at the lefttop
rc2.left = 0;
rc2.top = 0;
rc2.right = rc.right - rc.left;
rc2.bottom = rc.bottom - rc.top;
IntPtr destdc = GetDC(hwnd); //hwnd must be the handle of form,not control
IntPtr Memdc = CreateCompatibleDC(destdc); // Set up a memory DC where we'll draw the text.
IntPtr bitmap;
IntPtr bitmapOld = IntPtr.Zero;
IntPtr logfnotOld;
int uFormat = DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX; //text format
BITMAPINFO dib = new BITMAPINFO();
dib.bmiHeader.biHeight = -(rc.bottom - rc.top); // negative because DrawThemeTextEx() uses a top-down DIB
dib.bmiHeader.biWidth = rc.right - rc.left;
dib.bmiHeader.biPlanes = 1;
dib.bmiHeader.biSize = Marshal.SizeOf(typeof(BITMAPINFOHEADER));
dib.bmiHeader.biBitCount = 32;
dib.bmiHeader.biCompression = BI_RGB;
if (!(SaveDC(Memdc) == 0))
{
bitmap = CreateDIBSection(Memdc, ref dib, DIB_RGB_COLORS, 0, IntPtr.Zero, 0); // Create a 32-bit bmp for use in offscreen drawing when glass is on
if (!(bitmap == IntPtr.Zero))
{
bitmapOld = SelectObject(Memdc, bitmap);
IntPtr hFont = font.ToHfont();
logfnotOld = SelectObject(Memdc, hFont);
try
{
System.Windows.Forms.VisualStyles.VisualStyleRenderer renderer = new System.Windows.Forms.VisualStyles.VisualStyleRenderer(System.Windows.Forms.VisualStyles.VisualStyleElement.Window.Caption.Active);
DTTOPTS dttOpts = new DTTOPTS();
dttOpts.dwSize = (uint)Marshal.SizeOf(typeof(DTTOPTS));
dttOpts.dwFlags = DTT_COMPOSITED | DTT_GLOWSIZE;
dttOpts.iGlowSize = iglowSize;
DrawThemeTextEx(renderer.Handle, Memdc, 0, 0, text, -1, uFormat, ref rc2, ref dttOpts);
BitBlt(destdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, Memdc, 0, 0, SRCCOPY);
}
catch (Exception e)
{
Trace.WriteLine(e.Message);
}
//Remember to clean up
SelectObject(Memdc, bitmapOld);
SelectObject(Memdc, logfnotOld);
DeleteObject(bitmap);
DeleteObject(hFont);
ReleaseDC(Memdc, -1);
DeleteDC(Memdc);
}
}
}
}
public static bool ScriptGetFontProperties(System.Drawing.Font font, out Uniscribe.SCRIPT_FONTPROPERTIES sfp)
{
sfp = new Uniscribe.SCRIPT_FONTPROPERTIES();
if (font == null)
{
return(false);
}
// HFONT hfont = initialize your font;
IntPtr hfont = font.ToHfont();
IntPtr psc = IntPtr.Zero; // Initialize to NULL, will be filled lazily.
IntPtr hdcSrc = IntPtr.Zero;
IntPtr HDC = IntPtr.Zero; // Don't give it a DC unless we have to.
// HFONT old_font = NULL;
IntPtr old_font = IntPtr.Zero;
uint res = 0;
sfp = new Uniscribe.SCRIPT_FONTPROPERTIES();
sfp.cBytes = Marshal.SizeOf(typeof(Uniscribe.SCRIPT_FONTPROPERTIES));
for (int i = 0; i < 2; i++)
{
try
{
res = 0;
res = Uniscribe.ScriptGetFontProperties(HDC, ref psc, ref sfp);
if (res != 0)
{
if (res == Win32.E_PENDING)
{
throw new ArgumentException();
}
else
{
throw new Exception(); // Some kind of error.
}
}
break;
}
catch (ArgumentException)
{
// ... select font into hdc ...
hdcSrc = Win32.GetDC(IntPtr.Zero);
HDC = Win32.CreateCompatibleDC(hdcSrc);
old_font = Win32.SelectObject(HDC, hfont);
// Loop again...
continue;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
break;
}
}
if (old_font != IntPtr.Zero)
{
Win32.SelectObject(HDC, old_font); // Put back the previous font.
}
Win32.ReleaseDC(IntPtr.Zero, HDC);
Win32.ReleaseDC(IntPtr.Zero, hdcSrc);
// Need to tell Uniscribe to delete the cache we were using. If you are going
// to keep the HFONT around, you should probably also keep the cache.
// ScriptFreeCache(psc);
Win32.DeleteObject(hfont);
return(res == 0);
}
/// <summary>
/// Create the font image using GDI+ functionality.
/// </summary>
void CreateGdiFontImage(XFont font, XPdfFontOptions options /*, XPrivateFontCollection privateFontCollection*/)
{
System.Drawing.Font gdiFont = font.RealizeGdiFont();
#if DEBUG_
logFont = new NativeMethods.LOGFONT();
gdiFont.ToLogFont(logFont);
Debug.WriteLine("FontData: " + logFont.lfFaceName);
#endif
this.data = null;
// PFC
//if (privateFontCollection != null)
//{
// //XPrivateFont privateFont = privateFontCollection.FindFont(logFont.lfFaceName, logFont.lfWeight >= 700, logFont.lfItalic > 0);
// XGlyphTypeface privateFont = privateFontCollection.FindFont(font.Name, font.Bold, font.Italic);
// if (privateFont != null)
// {
// //////int size = privateFont.GetData(ref this.data);
// //////if (size > 0)
// //////{
// ////// this.data = new byte[size];
// ////// privateFont.GetData(ref this.data, size);
// //////}
// }
//}
if (this.data == null)
{
var assembly = FontDataConfig.ResourceAssembly;
var name = string.Format("{0}.FontHacks.{1}{2}{3}.fontdat",
assembly != null ? assembly.GetName().Name : string.Empty,
font.Name,
font.Bold ? ".Bold" : string.Empty,
font.Italic ? ".Italic" : string.Empty);
if (assembly != null && new List <string>(assembly.GetManifestResourceNames()).Contains(name))
{
System.Diagnostics.Debug.WriteLine("*** Reading fontdata from Resource");
using (var s = assembly.GetManifestResourceStream(name))
{
this.data = new byte[s.Length];
s.Read(this.data, 0, (int)s.Length);
}
}
else
{
System.Diagnostics.Debug.WriteLine("*** Reading fontdata from GDI+");
int error;
IntPtr hfont = gdiFont.ToHfont();
using (var dcBmp = new Bitmap(100, 100))
using (var dc = Graphics.FromImage(dcBmp))
{
IntPtr hdc = dc.GetHdc();
error = Marshal.GetLastWin32Error();
IntPtr oldFont = NativeMethods.SelectObject(hdc, hfont);
error = Marshal.GetLastWin32Error();
// size is exactly the size of the font file.
int size = NativeMethods.GetFontData(hdc, 0, 0, null, 0);
error = Marshal.GetLastWin32Error();
if (size > 0)
{
this.data = new byte[size];
int effectiveSize = NativeMethods.GetFontData(hdc, 0, 0, this.data, this.data.Length);
Debug.Assert(size == effectiveSize);
if (FontDataConfig.SaveFont)
{
FileExtensions.WriteFileBytes(this.data, string.Format("..\\..\\FontHacks\\{0}{1}{2}.fontdat",
font.Name,
font.Bold ? ".Bold" : string.Empty,
font.Italic ? ".Italic" : string.Empty));
}
NativeMethods.SelectObject(hdc, oldFont);
NativeMethods.ReleaseDC(IntPtr.Zero, hdc);
error.GetType();
}
else
{
// Sometimes size is -1 (GDI_ERROR), but I cannot determine why. It happens only with the font 'Symbol'.
// The issue occurs the first time in early 2005, when I start writing PDFsharp. I could not fix it and after
// some code refactoring the problem disappears.
// There was never a report from anyone about this issue.
// Now I get it again (while debugging QBX 2006). Maybe it is a problem with my PC at my home office.
// As a work-around I create a new font handle with a different height value. This works. Maybe the
// font file gets locked somewhere. Very very strange.
// IF SOMEONE ELSE COMES HERE PLEASE LET ME KNOW!
// Clean up old handles
NativeMethods.SelectObject(hdc, oldFont);
NativeMethods.ReleaseDC(IntPtr.Zero, hdc);
// Try again with new font handle
var logFont = new NativeMethods.LOGFONT();
gdiFont.ToLogFont(logFont);
logFont.lfHeight += 1; // force new handle
IntPtr hfont2 = NativeMethods.CreateFontIndirect(logFont);
hdc = NativeMethods.GetDC(IntPtr.Zero);
error = Marshal.GetLastWin32Error();
oldFont = NativeMethods.SelectObject(hdc, hfont2);
error = Marshal.GetLastWin32Error();
// size is exactly the size of the font file.
size = NativeMethods.GetFontData(hdc, 0, 0, null, 0);
error = Marshal.GetLastWin32Error();
if (size > 0)
{
this.data = new byte[size];
int effectiveSize = NativeMethods.GetFontData(hdc, 0, 0, this.data, this.data.Length);
Debug.Assert(size == effectiveSize);
}
NativeMethods.SelectObject(hdc, oldFont);
NativeMethods.ReleaseDC(IntPtr.Zero, hdc);
NativeMethods.DeleteObject(hfont2);
error.GetType();
}
}
}
if (this.data == null)
{
throw new InvalidOperationException("Internal error. Font data could not retrieved.");
}
}
}
protected override void WndProc(ref Message m)
{
switch (m.Msg)
{
case 0x000F: //WM_PAINT
if (parent.FullyCustomHeader)
{
Win32.RECT update = new Win32.RECT();
if (Win32.GetUpdateRect(m.HWnd, ref update, false) == 0)
{
break;
}
//Fill the paintstruct
Win32.PAINTSTRUCT ps = new Win32.PAINTSTRUCT();
IntPtr hdc = Win32.BeginPaint(m.HWnd, ref ps);
//Create graphics object from the hdc
Graphics g = Graphics.FromHdc(hdc);
//Get the non-item rectangle
int left = 0;
Win32.RECT itemRect = new Win32.RECT();
for (int i = 0; i < parent.Columns.Count; i++)
{
//HDM_GETITEMRECT
Win32.SendMessage(m.HWnd, 0x1200 + 7, i, ref itemRect);
left += itemRect.right - itemRect.left;
}
parent.headerHeight = itemRect.bottom - itemRect.top;
if (left >= ps.rcPaint.left)
{
left = ps.rcPaint.left;
}
Rectangle r = new Rectangle(left, ps.rcPaint.top,
ps.rcPaint.right - left, ps.rcPaint.bottom - ps.rcPaint.top);
Rectangle r1 = new Rectangle(ps.rcPaint.left, ps.rcPaint.top,
ps.rcPaint.right - left, ps.rcPaint.bottom - ps.rcPaint.top);
g.FillRectangle(new SolidBrush(parent.headerBackColor), r);
//If we have a valid event handler - call it
if (parent.DrawHeader != null && !parent.DefaultCustomDraw)
{
parent.DrawHeader(new DrawHeaderEventArgs(g, r,
itemRect.bottom - itemRect.top));
}
else
{
parent.DrawHeaderBorder(new DrawHeaderEventArgs(g, r,
itemRect.bottom - itemRect.top));
}
//Now we have to check if we have owner-draw columns and fill
//the DRAWITEMSTRUCT appropriately
int counter = 0;
foreach (ListColumn mm in parent.Columns)
{
if (mm.OwnerDraw)
{
Win32.DRAWITEMSTRUCT dis = new Win32.DRAWITEMSTRUCT();
dis.ctrlType = 100; //ODT_HEADER
dis.hwnd = m.HWnd;
dis.hdc = hdc;
dis.itemAction = 0x0001; //ODA_DRAWENTIRE
dis.itemID = counter;
//Must find if some item is pressed
Win32.HDHITTESTINFO hi = new Win32.HDHITTESTINFO();
hi.pt.X = parent.PointToClient(MousePosition).X;
hi.pt.Y = parent.PointToClient(MousePosition).Y;
int hotItem = Win32.SendMessage(m.HWnd, 0x1200 + 6, 0, ref hi);
//If clicked on a divider - we don't have hot item
if (hi.flags == 0x0004 || hotItem != counter)
{
hotItem = -1;
}
if (hotItem != -1 && mouseDown)
{
dis.itemState = 0x0001; //ODS_SELECTED
}
else
{
dis.itemState = 0x0020;
}
//HDM_GETITEMRECT
Win32.SendMessage(m.HWnd, 0x1200 + 7, counter, ref itemRect);
dis.rcItem = itemRect;
//Send message WM_DRAWITEM
Win32.SendMessage(parent.Handle, 0x002B, 0, ref dis);
}
counter++;
}
Win32.EndPaint(m.HWnd, ref ps);
}
else
{
base.WndProc(ref m);
}
break;
case 0x0014: //WM_ERASEBKGND
//We don't need to do anything here in order to reduce flicker
if (parent.FullyCustomHeader)
{
break;
}
else
{
base.WndProc(ref m);
}
break;
case 0x0201: //WM_LBUTTONDOWN
mouseDown = true;
base.WndProc(ref m);
break;
case 0x0202: //WM_LBUTTONUP
mouseDown = false;
base.WndProc(ref m);
break;
case 0x1200 + 5: //HDM_LAYOUT
base.WndProc(ref m);
break;
case 0x0030: //WM_SETFONT
if (parent.IncreaseHeaderHeight > 0)
{
System.Drawing.Font f = new System.Drawing.Font(parent.Font.Name,
parent.Font.SizeInPoints + parent.IncreaseHeaderHeight);
m.WParam = f.ToHfont();
}
base.WndProc(ref m);
break;
default:
base.WndProc(ref m);
break;
}
}
internal static Size MeasureTextInternal (IDeviceContext dc, string text, Font font, Size proposedSize, TextFormatFlags flags, bool useMeasureString)
{
if (!useMeasureString && !XplatUI.RunningOnUnix) {
// Tell DrawText to calculate size instead of draw
flags |= (TextFormatFlags)1024; // DT_CALCRECT
IntPtr hdc = dc.GetHdc ();
XplatUIWin32.RECT r = XplatUIWin32.RECT.FromRectangle (new Rectangle (Point.Empty, proposedSize));
IntPtr prevobj;
if (font != null) {
prevobj = SelectObject (hdc, font.ToHfont ());
Win32DrawText (hdc, text, text.Length, ref r, (int)flags);
prevobj = SelectObject (hdc, prevobj);
DeleteObject (prevobj);
}
else {
Win32DrawText (hdc, text, text.Length, ref r, (int)flags);
}
dc.ReleaseHdc ();
// Really, I am just making something up here, which as far as I can tell, MS
// just makes something up as well. This will require lots of tweaking to match MS. :(
Size retval = r.ToRectangle ().Size;
if (retval.Width > 0 && (flags & TextFormatFlags.NoPadding) == 0) {
retval.Width += 6;
retval.Width += (int)retval.Height / 8;
}
return retval;
}
else {
StringFormat sf = FlagsToStringFormat (flags);
Size retval;
if (dc is Graphics)
retval = (dc as Graphics).MeasureString (text, font, proposedSize.Width == 0 ? Int32.MaxValue : proposedSize.Width, sf).ToSize ();
else
retval = TextRenderer.MeasureString (text, font, proposedSize.Width == 0 ? Int32.MaxValue : proposedSize.Width, sf).ToSize ();
if (retval.Width > 0 && (flags & TextFormatFlags.NoPadding) == 0)
retval.Width += 9;
return retval;
}
}
private static void DrawOnHDC(IntPtr compatHdc, string text, Font font, Padding internalBounds,
Rectangle bounds, Color color, TextFormatFlags formatFlags, IThemeTextOption[] options) {
//Create the Font to use
IntPtr hFont = font.ToHfont();
Native.GDI.SelectObject(compatHdc, hFont);
//Get theme renderer
VisualStyleRenderer renderer = new VisualStyleRenderer(VisualStyleElement.Window.Caption.Active);
//Prepare options
NativeMethods.DTTOPTS dttOpts = new NativeMethods.DTTOPTS();
dttOpts.dwSize = Marshal.SizeOf(dttOpts);
dttOpts.dwFlags = NativeMethods.DTTOPSFlags.DTT_COMPOSITED | NativeMethods.DTTOPSFlags.DTT_TEXTCOLOR;
dttOpts.crText = ColorTranslator.ToWin32(color);
foreach (IThemeTextOption op in options)
op.Apply(ref dttOpts);
//Set full bounds with padding
Native.RECT RECT = new Native.RECT(internalBounds.Left, internalBounds.Top,
bounds.Width - internalBounds.Right, bounds.Height - internalBounds.Bottom);
//Draw
int ret = NativeMethods.DrawThemeTextEx(renderer.Handle, compatHdc, 0, 0, text, -1, (int)formatFlags, ref RECT, ref dttOpts);
if (ret != 0)
Marshal.ThrowExceptionForHR(ret);
//Clean up
Native.GDI.DeleteObject(hFont);
}
private TextureBase CreateTextureByWinAPI(PPDDevice device)
{
var metrics = new WinAPI.GLYPHMETRICS();
var tmetrics = new WinAPI.TEXTMETRIC();
var matrix = new WinAPI.MAT2();
TextureBase texture = null;
matrix.eM11.value = 1;
matrix.eM12.value = 0;
matrix.eM21.value = 0;
matrix.eM22.value = 1;
using (var font = new System.Drawing.Font(FaceName, ActualFontSize))
using (Graphics g = Graphics.FromHwnd(IntPtr.Zero))
{
var hdc = g.GetHdc();
var prev = WinAPI.SelectObject(hdc, font.ToHfont());
var bufferSize = (int)WinAPI.GetGlyphOutlineW(hdc, Character, (uint)6, out metrics, 0, IntPtr.Zero, ref matrix);
var buffer = Marshal.AllocHGlobal(bufferSize);
try
{
uint ret;
if ((ret = WinAPI.GetGlyphOutlineW(hdc, Character, (uint)6, out metrics, (uint)bufferSize, buffer, ref matrix)) > 0 && WinAPI.GetTextMetrics(hdc, ref tmetrics))
{
int iBmp_w = metrics.gmBlackBoxX + (4 - (metrics.gmBlackBoxX % 4)) % 4;
int iBmp_h = metrics.gmBlackBoxY;
int iOfs_x = metrics.gmptGlyphOrigin.x, iOfs_y = tmetrics.ascent - metrics.gmptGlyphOrigin.y;
width = metrics.gmCellIncX;
height = tmetrics.height;
t_width = Utility.UpperPowerOfTwo(Math.Max(width, iBmp_w + iOfs_x));
t_height = Utility.UpperPowerOfTwo(height);
texture = ((PPDFramework.Texture.DX9.TextureFactory)TextureFactoryManager.Factory).Create(device, t_width, t_height, 1, SharpDX.Direct3D9.Pool.SystemMemory, true);
using (var textureData = texture.GetTextureData())
{
var rec = textureData.DataStream;
try
{
byte[] data = new byte[bufferSize];
Marshal.Copy(buffer, data, 0, bufferSize);
int offset1 = (iOfs_x + iOfs_y * t_width) * 4;
int offset2 = (iOfs_x + t_width - iOfs_x - iBmp_w) * 4;
WinAPI.ZeroMemory(rec.DataPointer, (uint)rec.Length);
var writedata = new byte[] { (byte)255, (byte)255, (byte)255, (byte)255 };
for (int i = 0; i < iBmp_h; i++)
{
for (int j = 0; j < iBmp_w; j++)
{
var alpha = (byte)((255 * data[j + iBmp_w * i]) / 64);
writedata[0] = writedata[1] = writedata[2] = alpha;
writedata[3] = (byte)alpha;
if (j == 0)
{
if (i == 0)
{
rec.Seek(offset1, System.IO.SeekOrigin.Current);
}
else
{
rec.Seek(offset2, System.IO.SeekOrigin.Current);
}
}
rec.Write(writedata, 0, writedata.Length);
}
}
}
catch
{
Console.WriteLine("CharTextureError");
}
}
}
}
finally
{
WinAPI.SelectObject(hdc, prev);
WinAPI.DeleteObject(prev);
g.ReleaseHdc(hdc);
Marshal.FreeHGlobal(buffer);
}
}
return(texture);
}
public MyFont(System.Drawing.Font f)
{
this.myFont = f;
this.hFont = f.ToHfont();
}
private FontData RenderGlyphsCleartype(SysDrawFont internalFont, FontCharSet charSet, bool monospace)
{
FontGlyphData[] glyphs = new FontGlyphData[charSet.Chars.Length];
for (int i = 0; i < glyphs.Length; i++)
{
glyphs[i].Glyph = charSet.Chars[i];
}
int bodyAscent = 0;
int baseLine = 0;
int descent = 0;
int ascent = 0;
int cols;
int rows;
cols = rows = (int)Math.Ceiling(Math.Sqrt(glyphs.Length));
IntPtr hFont = internalFont.ToHfont();
PixelData pixelLayer = new PixelData(
MathF.RoundToInt(cols * internalFont.Size * 1.2f),
MathF.RoundToInt(rows * internalFont.Height * 1.2f),
ColorRgba.TransparentBlack);
Bitmap measureBm = new Bitmap(1, 1);
Rect[] atlas = new Rect[glyphs.Length];
PixelData[] glyphBitmaps = new PixelData[glyphs.Length];
using (Graphics measureGraphics = Graphics.FromImage(measureBm)) {
IntPtr measureHdc = measureGraphics.GetHdc();
int x = 1;
int y = 1;
for (int i = 0; i < glyphs.Length; ++i)
{
string str = glyphs[i].Glyph.ToString(CultureInfo.InvariantCulture);
bool isSpace = str == " ";
Size charSize;
GetTextExtentPoint32(measureHdc, str, str.Length, out charSize);
// Rasterize a single glyph for rendering
Bitmap bm = new Bitmap(Math.Max(1, charSize.Width), internalFont.Height + 1);
using (Graphics glyphGraphics = Graphics.FromImage(bm)) {
glyphGraphics.Clear(SystemColors.Window);
IntPtr hdc = glyphGraphics.GetHdc();
SelectObject(hdc, hFont);
SetTextColor(hdc, (0 /*B*/ << 16) | (0 /*G*/ << 8) | 0 /*R*/);
TextOut(hdc, 0, 0, str, str.Length);
glyphGraphics.ReleaseHdc(hdc);
}
glyphBitmaps[i] = new PixelData();
glyphBitmaps[i].FromBitmap(bm);
PixelData glyphTempTypo = glyphBitmaps[i];
// Update xy values if it doesn't fit anymore
if (x + glyphBitmaps[i].Width + 2 > pixelLayer.Width)
{
x = 1;
y += internalFont.Height + MathF.Clamp((int)MathF.Ceiling(internalFont.Height * 0.1875f), 3, 10);
}
// Memorize atlas coordinates & glyph data
glyphs[i].Size = glyphBitmaps[i].Size;
glyphs[i].Offset.X = glyphBitmaps[i].Width - glyphTempTypo.Width;
glyphs[i].Offset.Y = 0; // TTF fonts are rendered on blocks that are the whole size of the height - so no need for offset
if (isSpace)
{
glyphs[i].Size.X /= 2;
glyphs[i].Offset.X /= 2;
}
glyphs[i].Advance = glyphs[i].Size.X - glyphs[i].Offset.X;
atlas[i].X = x;
atlas[i].Y = y;
atlas[i].W = glyphBitmaps[i].Width;
atlas[i].H = (internalFont.Height + 1);
// Draw it onto the font surface
glyphBitmaps[i].DrawOnto(pixelLayer, BlendMode.Solid, x, y);
x += glyphBitmaps[i].Width + MathF.Clamp((int)MathF.Ceiling(internalFont.Height * 0.125f), 2, 10);
}
measureGraphics.ReleaseHdc(measureHdc);
}
// ToDo: finally
DeleteObject(hFont);
// Monospace offset and advance adjustments
if (monospace)
{
float maxGlyphWidth = 0;
for (int i = 0; i < glyphs.Length; i++)
{
maxGlyphWidth = Math.Max(maxGlyphWidth, glyphs[i].Size.X);
}
for (int i = 0; i < glyphs.Length; ++i)
{
glyphs[i].Offset.X -= (int)Math.Round((maxGlyphWidth - glyphs[i].Size.X) / 2.0f);
glyphs[i].Advance = maxGlyphWidth;
}
}
// Determine Font properties
{
float lineSpacing = internalFont.FontFamily.GetLineSpacing(internalFont.Style);
float emHeight = internalFont.FontFamily.GetEmHeight(internalFont.Style);
float cellAscent = internalFont.FontFamily.GetCellAscent(internalFont.Style);
float cellDescent = internalFont.FontFamily.GetCellDescent(internalFont.Style);
ascent = (int)Math.Round(cellAscent * internalFont.Size / emHeight);
bodyAscent /= charSet.CharBodyAscentRef.Length;
baseLine /= charSet.CharBaseLineRef.Length;
descent = (int)Math.Round(((float)descent / charSet.CharDescentRef.Length) - (float)baseLine);
}
// Aggregate rendered and generated data into our return value
FontMetrics metrics = new FontMetrics(
size: internalFont.SizeInPoints,
height: (int)internalFont.Height,
ascent: ascent,
bodyAscent: bodyAscent,
descent: descent,
baseLine: baseLine,
monospace: monospace);
// Determine kerning pairs
FontKerningPair[] kerningPairs = null;
if (monospace)
{
kerningPairs = null;
}
else
{
kerningPairs = this.GatherKerningPairs(glyphs, metrics, glyphBitmaps);
}
return(new FontData(pixelLayer, atlas, glyphs, metrics, kerningPairs));
}
internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent) {
IntPtr dc;
IntPtr prevobj;
TEXTMETRIC tm;
tm = new TEXTMETRIC();
dc = Win32GetDC (IntPtr.Zero);
prevobj = Win32SelectObject (dc, font.ToHfont ());
if (Win32GetTextMetrics (dc, ref tm) == false) {
prevobj = Win32SelectObject (dc, prevobj);
Win32DeleteObject (prevobj);
Win32ReleaseDC (IntPtr.Zero, dc);
ascent = 0;
descent = 0;
return false;
}
prevobj = Win32SelectObject (dc, prevobj);
Win32DeleteObject (prevobj);
Win32ReleaseDC (IntPtr.Zero, dc);
ascent = tm.tmAscent;
descent = tm.tmDescent;
return true;
}
internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, Color backColor, TextFormatFlags flags, bool useDrawString)
{
if (dc == null)
throw new ArgumentNullException ("dc");
if (text == null || text.Length == 0)
return;
// We use MS GDI API's unless told not to, or we aren't on Windows
if (!useDrawString && !XplatUI.RunningOnUnix) {
if ((flags & TextFormatFlags.VerticalCenter) == TextFormatFlags.VerticalCenter || (flags & TextFormatFlags.Bottom) == TextFormatFlags.Bottom)
flags |= TextFormatFlags.SingleLine;
// Calculate the text bounds (there is often padding added)
Rectangle new_bounds = PadRectangle (bounds, flags);
new_bounds.Offset ((int)(dc as Graphics).Transform.OffsetX, (int)(dc as Graphics).Transform.OffsetY);
IntPtr hdc = IntPtr.Zero;
bool clear_clip_region = false;
// If we need to use the graphics clipping region, add it to our hdc
if ((flags & TextFormatFlags.PreserveGraphicsClipping) == TextFormatFlags.PreserveGraphicsClipping) {
Graphics graphics = (Graphics)dc;
Region clip_region = graphics.Clip;
if (!clip_region.IsInfinite (graphics)) {
IntPtr hrgn = clip_region.GetHrgn (graphics);
hdc = dc.GetHdc ();
SelectClipRgn (hdc, hrgn);
DeleteObject (hrgn);
clear_clip_region = true;
}
}
if (hdc == IntPtr.Zero)
hdc = dc.GetHdc ();
// Set the fore color
if (foreColor != Color.Empty)
SetTextColor (hdc, ColorTranslator.ToWin32 (foreColor));
// Set the back color
if (backColor != Color.Transparent && backColor != Color.Empty) {
SetBkMode (hdc, 2); //1-Transparent, 2-Opaque
SetBkColor (hdc, ColorTranslator.ToWin32 (backColor));
}
else {
SetBkMode (hdc, 1); //1-Transparent, 2-Opaque
}
XplatUIWin32.RECT r = XplatUIWin32.RECT.FromRectangle (new_bounds);
IntPtr prevobj;
if (font != null) {
prevobj = SelectObject (hdc, font.ToHfont ());
Win32DrawText (hdc, text, text.Length, ref r, (int)flags);
prevobj = SelectObject (hdc, prevobj);
DeleteObject (prevobj);
}
else {
Win32DrawText (hdc, text, text.Length, ref r, (int)flags);
}
if (clear_clip_region)
SelectClipRgn (hdc, IntPtr.Zero);
dc.ReleaseHdc ();
}
// Use Graphics.DrawString as a fallback method
else {
Graphics g;
IntPtr hdc = IntPtr.Zero;
if (dc is Graphics)
g = (Graphics)dc;
else {
hdc = dc.GetHdc ();
g = Graphics.FromHdc (hdc);
}
StringFormat sf = FlagsToStringFormat (flags);
Rectangle new_bounds = PadDrawStringRectangle (bounds, flags);
g.DrawString (text, font, ThemeEngine.Current.ResPool.GetSolidBrush (foreColor), new_bounds, sf);
if (!(dc is Graphics)) {
g.Dispose ();
dc.ReleaseHdc ();
}
}
}
public Font(System.Drawing.Font manFont)
{
_gdiFont = manFont.ToHfont();
}
public static bool ScriptGetCMap(string str, System.Drawing.Font font, Uniscribe.SCRIPT_FONTPROPERTIES sfp)
{
if (font == null)
{
return(false);
}
uint res = 0;
// HFONT hfont = initialize your font;
IntPtr hfont = font.ToHfont();
IntPtr psc = IntPtr.Zero; // Initialize to NULL, will be filled lazily.
IntPtr hdcSrc = IntPtr.Zero;
IntPtr HDC = IntPtr.Zero; // Don't give it a DC unless we have to.
// HFONT old_font = NULL;
IntPtr old_font = IntPtr.Zero;
ushort[] pwOutGlyphs = new ushort[str.Length];
for (int max = 1000; max > 0; --max)
{
try
{
res = 0;
res = Uniscribe.ScriptGetCMap(HDC, ref psc, str, str.Length, 0, pwOutGlyphs);
if (res != 0)
{
// Different types of failure...
if (res == Win32.E_PENDING)
{
// Need to select the font for the call. Don't do this if we don't have to
// since it may be slow.
throw new ArgumentException();
}
if (res == Win32.E_HANDLE)
{
// The font or the operating system does not support glyph indexes.
throw new Exception();
}
else if (res == Win32.S_FALSE)
{
// Some of the Unicode code points were mapped to the default glyph.
throw new Exception();
}
}
// call ScriptGetFontProperties
int defaultGlyph = sfp.wgDefault;
for (int i = 0; i < str.Length; i++)
{
if (pwOutGlyphs[i] == defaultGlyph)
{
// character with that index is not available in selected font
}
}
break;
}
catch (ArgumentException)
{
// ... select font into hdc ...
hdcSrc = Win32.GetDC(IntPtr.Zero);
HDC = Win32.CreateCompatibleDC(hdcSrc);
old_font = Win32.SelectObject(HDC, hfont);
// Loop again...
continue;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
break;
}
}
if (old_font != IntPtr.Zero)
{
Win32.SelectObject(HDC, old_font); // Put back the previous font.
}
Win32.ReleaseDC(IntPtr.Zero, HDC);
Win32.ReleaseDC(IntPtr.Zero, hdcSrc);
// Need to tell Uniscribe to delete the cache we were using. If you are going
// to keep the HFONT around, you should probably also keep the cache.
// ScriptFreeCache(psc);
Win32.DeleteObject(hfont);
return(res == 0);
}
private List <NameRecord> GetFontNames(System.Drawing.Font font)
{
return(GetFontNames(font.ToHfont()));
}
