/// <include file='doc\FontDialog.uex' path='docs/doc[@for="FontDialog.UpdateFont"]/*' />
/// <devdoc>
/// </devdoc>
/// <internalonly/>
private void UpdateFont(NativeMethods.LOGFONT lf)
{
IntPtr screenDC = UnsafeNativeMethods.GetDC(NativeMethods.NullHandleRef);
try {
Font fontInWorldUnits = null;
try {
IntSecurity.UnmanagedCode.Assert();
try {
fontInWorldUnits = Font.FromLogFont(lf, screenDC);
}
finally {
CodeAccessPermission.RevertAssert();
}
// The dialog claims its working in points (a device-independent unit),
// but actually gives us something in world units (device-dependent).
font = ControlPaint.FontInPoints(fontInWorldUnits);
}
finally {
if (fontInWorldUnits != null)
{
fontInWorldUnits.Dispose();
}
}
}
finally {
UnsafeNativeMethods.ReleaseDC(NativeMethods.NullHandleRef, new HandleRef(null, screenDC));
}
}
/// <include file='doc\StyleBuilderSite.uex' path='docs/doc[@for="StyleBuilderSite.GetUIFont"]/*' />
/// <devdoc>
/// </devdoc>
public Font GetUIFont()
{
Font uiFont = null;
if (site != null)
{
try {
IUIHostLocale uiService = (IUIHostLocale)QueryService(typeof(IUIHostLocale));
_LOGFONTW lfUnicode = new _LOGFONTW();
uiService.GetDialogFont(lfUnicode);
NativeMethods.LOGFONT lfAuto = lfUnicode.ToLOGFONT_Internal();
uiFont = Font.FromLogFont(lfAuto);
}
catch (Exception e) {
Debug.Fail(e.ToString());
}
}
if (uiFont == null)
{
try {
// this is what VS returns...
uiFont = new Font("Tahoma", 11, FontStyle.Regular, GraphicsUnit.World);
}
catch {
uiFont = Control.DefaultFont;
}
}
return(uiFont);
}
internal NativeMethods.LOGFONT ToLOGFONT_Internal()
{
_LOGFONTW lfUnicode = this;
// No way today to define a char array in IDL that is interop compatible, so
// we've got to read everything in here!
//
StringBuilder sb = new StringBuilder();
int ch = 0;
while (ch < 32)
{
FieldInfo fi = (typeof(_LOGFONTW)).GetField("lfFaceName" + ch.ToString());
if (fi == null)
{
break;
}
Object o = fi.GetValue(this);
try {
short charVal = (short)o;
if (charVal == 0)
{
break;
}
sb.Append((char)charVal);
}
catch (InvalidCastException) {
return(null);
}
ch++;
}
// Copy one LOGFONT to the other...
NativeMethods.LOGFONT lfAuto = new NativeMethods.LOGFONT();
lfAuto.lfHeight = lfUnicode.lfHeight;
lfAuto.lfWidth = lfUnicode.lfWidth;
lfAuto.lfEscapement = lfUnicode.lfEscapement;
lfAuto.lfOrientation = lfUnicode.lfOrientation;
lfAuto.lfWeight = lfUnicode.lfWeight;
lfAuto.lfItalic = lfUnicode.lfItalic;
lfAuto.lfUnderline = lfUnicode.lfUnderline;
lfAuto.lfStrikeOut = lfUnicode.lfStrikeOut;
lfAuto.lfCharSet = lfUnicode.lfCharSet;
lfAuto.lfOutPrecision = lfUnicode.lfOutPrecision;
lfAuto.lfClipPrecision = lfUnicode.lfClipPrecision;
lfAuto.lfQuality = lfUnicode.lfQuality;
lfAuto.lfPitchAndFamily = lfUnicode.lfPitchAndFamily;
lfAuto.lfFaceName = sb.ToString();
return(lfAuto);
}
internal NativeMethods.LOGFONT GetLogfont()
{
IntPtr hfont = GetFont();
Debug.Assert(hfont != IntPtr.Zero, "WindowsEditBox.GetLogfont got null HFONT");
NativeMethods.LOGFONT logfont = new NativeMethods.LOGFONT();
int cb = Marshal.SizeOf(typeof(NativeMethods.LOGFONT));
if (Misc.GetObjectW(hfont, cb, ref logfont) != cb)
{
Debug.Assert(false, "WindowsEditBox.GetObject unexpected return value");
}
return(logfont);
}
// returns the value of the corresponding text attribute
private static object GetFontSize(NativeMethods.LOGFONT logfont)
{
// note: this assumes integral point sizes. violating this assumption would confuse the user
// because they set something to 7 point but reports that it is, say 7.2 point, due to the rounding.
IntPtr hdc = Misc.GetDC(IntPtr.Zero);
if (hdc == IntPtr.Zero)
{
return(null);
}
int lpy = UnsafeNativeMethods.GetDeviceCaps(hdc, NativeMethods.LOGPIXELSY);
Misc.ReleaseDC(IntPtr.Zero, hdc);
return(Math.Round((double)(-logfont.lfHeight) * 72 / lpy));
}
/// <include file='doc\FontDialog.uex' path='docs/doc[@for="FontDialog.HookProc"]/*' />
/// <devdoc>
/// <para>
/// Specifies the common dialog box hook procedure that is overridden to add
/// specific functionality to a common dialog box.
/// </para>
/// </devdoc>
protected override IntPtr HookProc(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam)
{
switch (msg)
{
case NativeMethods.WM_COMMAND:
if ((int)wparam == 0x402)
{
NativeMethods.LOGFONT lf = new NativeMethods.LOGFONT();
UnsafeNativeMethods.SendMessage(new HandleRef(null, hWnd), NativeMethods.WM_CHOOSEFONT_GETLOGFONT, 0, lf);
UpdateFont(lf);
int index = (int)UnsafeNativeMethods.SendDlgItemMessage(new HandleRef(null, hWnd), 0x473, NativeMethods.CB_GETCURSEL, IntPtr.Zero, IntPtr.Zero);
if (index != NativeMethods.CB_ERR)
{
UpdateColor((int)UnsafeNativeMethods.SendDlgItemMessage(new HandleRef(null, hWnd), 0x473,
NativeMethods.CB_GETITEMDATA, (IntPtr)index, IntPtr.Zero));
}
if (NativeWindow.WndProcShouldBeDebuggable)
{
OnApply(EventArgs.Empty);
}
else
{
try
{
OnApply(EventArgs.Empty);
}
catch (Exception e)
{
Application.OnThreadException(e);
}
}
}
break;
case NativeMethods.WM_INITDIALOG:
if (!showColor)
{
IntPtr hWndCtl = UnsafeNativeMethods.GetDlgItem(new HandleRef(null, hWnd), NativeMethods.cmb4);
SafeNativeMethods.ShowWindow(new HandleRef(null, hWndCtl), NativeMethods.SW_HIDE);
hWndCtl = UnsafeNativeMethods.GetDlgItem(new HandleRef(null, hWnd), NativeMethods.stc4);
SafeNativeMethods.ShowWindow(new HandleRef(null, hWndCtl), NativeMethods.SW_HIDE);
}
break;
}
return(base.HookProc(hWnd, msg, wparam, lparam));
}
public Font GetFont(IDeviceContext dc, FontProperty prop)
{
if (dc == null)
{
throw new ArgumentNullException(nameof(dc));
}
//valid values are 0xa29 to 0xa29
if (!ClientUtils.IsEnumValid(prop, (int)prop, (int)FontProperty.GlyphFont, (int)FontProperty.GlyphFont))
{
throw new InvalidEnumArgumentException(nameof(prop), (int)prop, typeof(FontProperty));
}
NativeMethods.LOGFONT logfont = new NativeMethods.LOGFONT();
using (WindowsGraphicsWrapper wgr = new WindowsGraphicsWrapper(dc, AllGraphicsProperties))
{
HandleRef hdc = new HandleRef(wgr, wgr.WindowsGraphics.DeviceContext.Hdc);
lastHResult = SafeNativeMethods.GetThemeFont(new HandleRef(this, Handle), hdc, part, state, (int)prop, logfont);
}
Font font = null;
//check for a failed HR.
if (NativeMethods.Succeeded(lastHResult))
{
try
{
font = Font.FromLogFont(logfont);
}
catch (Exception e)
{
if (ClientUtils.IsSecurityOrCriticalException(e))
{
throw;
}
//Looks like the font was not true type
font = null;
}
}
return(font);
}
public MainForm()
{
InitializeComponent();
Graphics graphics = Graphics.FromHwnd(this.Handle);
IntPtr hdc = graphics.GetHdc();
var logfont = new NativeMethods.LOGFONT() { lfCharSet = NativeMethods.DEFAULT_CHARSET };
NativeMethods.EnumFontFamiliesEx(hdc, ref logfont, new NativeMethods.FONTENUMPROC(EnumFontFamExProc), IntPtr.Zero, 0);
graphics.ReleaseHdc();
if (comboBoxFontFamily.Items.Count > 0)
{
if (comboBoxFontFamily.Items.Contains("Consolas"))
{
comboBoxFontFamily.Text = "Consolas";
}
else
{
comboBoxFontFamily.SelectedIndex = 0;
}
}
}
internal static Font GetFontFromShell(IUIHostLocale locale)
{
_LOGFONTW font = new _LOGFONTW();
locale.GetDialogFont(font);
NativeMethods.LOGFONT lfAuto = font.ToLOGFONT_Internal();
Font shellFont = null;
if (lfAuto != null)
{
try {
shellFont = Font.FromLogFont(lfAuto);
}
catch (ArgumentException) {
}
}
if (shellFont == null)
{
shellFont = Control.DefaultFont;
}
return(shellFont);
}
// returns the value of the corresponding text attribute
private static object GetItalic(NativeMethods.LOGFONT logfont)
{
return(logfont.lfItalic != 0);
}
/// <summary>
/// Defines the common dialog box hook procedure that is overridden to add specific functionality to a common dialog box.
/// </summary>
/// <returns>
/// A zero value if the default dialog box procedure processes the message; a nonzero value if the default dialog box procedure ignores the message.
/// </returns>
/// <param name="hWnd">The handle to the dialog box window. </param><param name="msg">The message being received. </param><param name="wparam">Additional information about the message. </param><param name="lparam">Additional information about the message. </param>
protected override IntPtr HookProc(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam)
{
// This code is lifted directly from System.Windows.Forms.FontDialog
switch (msg)
{
case NativeMethods.WM_COMMAND:
if ((int)wparam == 0x402)
{
NativeMethods.LOGFONT lf = new NativeMethods.LOGFONT();
NativeMethods.SendMessage(new HandleRef(null, hWnd), NativeMethods.WM_CHOOSEFONT_GETLOGFONT, 0, lf);
this.UpdateFont(lf);
int index = (int)NativeMethods.SendDlgItemMessage(new HandleRef(null, hWnd), 0x473, NativeMethods.CB_GETCURSEL, IntPtr.Zero, IntPtr.Zero);
if (index != NativeMethods.CB_ERR)
{
this.UpdateColor((int)NativeMethods.SendDlgItemMessage(new HandleRef(null, hWnd), 0x473, NativeMethods.CB_GETITEMDATA, (IntPtr)index, IntPtr.Zero));
}
try
{
this.OnApply(EventArgs.Empty);
}
catch (Exception e)
{
Application.OnThreadException(e);
}
}
break;
case NativeMethods.WM_INITDIALOG:
if (!this.ShowColor)
{
IntPtr hWndCtl = NativeMethods.GetDlgItem(new HandleRef(null, hWnd), NativeMethods.cmb4);
NativeMethods.ShowWindow(new HandleRef(null, hWndCtl), NativeMethods.SW_HIDE);
hWndCtl = NativeMethods.GetDlgItem(new HandleRef(null, hWnd), NativeMethods.stc4);
NativeMethods.ShowWindow(new HandleRef(null, hWndCtl), NativeMethods.SW_HIDE);
}
break;
}
return base.HookProc(hWnd, msg, wparam, lparam);
}
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();
#if true
IntPtr hdc = NativeMethods.GetDC(IntPtr.Zero);
#else
NativeMethods.LOGFONT logFont = new NativeMethods.LOGFONT();
logFont.lfHeight = 30;
logFont.lfWidth = 0;
logFont.lfEscapement = 0;
logFont.lfOrientation = 0;
logFont.lfWeight = 400;
logFont.lfItalic = 0;
logFont.lfUnderline = 0;
logFont.lfStrikeOut = 0;
logFont.lfCharSet = 0;
logFont.lfOutPrecision = 0;
logFont.lfClipPrecision = 0;
logFont.lfQuality = 0;
logFont.lfPitchAndFamily = 0;
logFont.lfFaceName = "Arial";
gdiFont.ToLogFont(logFont);
hfont = NativeMethods.CreateFontIndirect(logFont);
// IntPtr hdc = NativeMethods.CreateDC("DISPLAY", null, null, IntPtr.Zero);
IntPtr hdc = NativeMethods.CreateCompatibleDC(IntPtr.Zero);
#endif
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);
}
/// <summary>
/// When overridden in a derived class, specifies a common dialog box.
/// </summary>
/// <returns>
/// true if the dialog box was successfully run; otherwise, false.
/// </returns>
/// <param name="hwndOwner">A value that represents the window handle of the owner window for the common dialog box. </param>
protected override bool RunDialog(IntPtr hwndOwner)
{
NativeMethods.LOGFONT lf;
NativeMethods.CHOOSEFONT cf;
IntPtr plf;
bool result;
int minSize;
int maxSize;
bool showColor;
lf = new NativeMethods.LOGFONT();
this.Font.ToLogFont(lf);
plf = Marshal.AllocHGlobal(Marshal.SizeOf(lf));
Marshal.StructureToPtr(lf, plf, false);
showColor = this.ShowColor || this.ShowEffects;
cf = new NativeMethods.CHOOSEFONT();
cf.lStructSize = Marshal.SizeOf(typeof(NativeMethods.CHOOSEFONT));
cf.Flags = this.GetFlags();
cf.hwndOwner = hwndOwner;
cf.lpfnHook = this.HookProc;
minSize = this.MinSize;
maxSize = this.MaxSize;
if (minSize > 0 || maxSize > 0)
{
cf.nSizeMin = minSize;
cf.nSizeMax = maxSize > 0 ? maxSize : int.MaxValue;
}
cf.rgbColors = ColorTranslator.ToWin32(showColor ? this.Color : Color.Black);
cf.lpLogFont = plf;
try
{
result = NativeMethods.ChooseFont(ref cf);
if (result)
{
// create a managed font from the updated LOGFONT
lf = (NativeMethods.LOGFONT)Marshal.PtrToStructure(plf, typeof(NativeMethods.LOGFONT));
if (!string.IsNullOrEmpty(lf.lfFaceName))
{
this.UpdateFont(lf);
}
// and update the color
if (showColor)
{
this.UpdateColor(cf.rgbColors);
}
}
}
finally
{
// always be freein' allocated memory!
Marshal.FreeHGlobal(plf);
}
return result;
}
/// <summary>
/// Create the font image using GDI+ functionality.
/// </summary>
void CreateGdiFontImage(XFont font, XPdfFontOptions options, XPrivateFontCollection privateFontCollection)
{
System.Drawing.Font gdiFont = font.RealizeGdiFont();
NativeMethods.LOGFONT logFont;
#if DEBUG_
logFont = new NativeMethods.LOGFONT();
gdiFont.ToLogFont(logFont);
Debug.WriteLine("FontData: " + logFont.lfFaceName);
#endif
this.data = null;
if (privateFontCollection != null)
{
//XPrivateFont privateFont = privateFontCollection.FindFont(logFont.lfFaceName, logFont.lfWeight >= 700, logFont.lfItalic > 0);
XPrivateFont privateFont = privateFontCollection.FindFont(font.Name, font.Bold, font.Italic);
if (privateFont != null)
{
int size = privateFont.GetFontData(ref this.data, 0);
if (size > 0)
{
this.data = new byte[size];
privateFont.GetFontData(ref this.data, size);
}
}
}
if (this.data == null)
{
int error;
IntPtr hfont = gdiFont.ToHfont();
IntPtr hdc = NativeMethods.GetDC(IntPtr.Zero);
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);
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
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.");
}
}
public static extern int GetThemeFont(HandleRef hTheme, HandleRef hdc, int iPartId, int iStateId, int iPropId, NativeMethods.LOGFONT pFont);
// returns the value of the corresponding text attribute
private static object GetUnderlineStyle(NativeMethods.LOGFONT logfont)
{
return(logfont.lfUnderline != 0 ? TextDecorationLineStyle.Single : TextDecorationLineStyle.None);
}
/// <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.");
}
}
}
internal static extern int GetObjectW(IntPtr hObject, int size, ref NativeMethods.LOGFONT lf);
// returns the value of the corresponding text attribute
private static object GetFontWeight(NativeMethods.LOGFONT logfont)
{
return(logfont.lfWeight);
}
// returns the value of the corresponding text attribute
private static object GetFontName(NativeMethods.LOGFONT logfont)
{
return(logfont.lfFaceName);
}
/// <include file='doc\FontDialog.uex' path='docs/doc[@for="FontDialog.RunDialog"]/*' />
/// <internalonly/>
/// <devdoc>
/// <para>
/// The actual implementation of running the dialog. Inheriting classes
/// should override this if they want to add more functionality, and call
/// base.runDialog() if necessary
///
/// </para>
/// </devdoc>
protected override bool RunDialog(IntPtr hWndOwner)
{
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
NativeMethods.CHOOSEFONT cf = new NativeMethods.CHOOSEFONT();
IntPtr screenDC = UnsafeNativeMethods.GetDC(NativeMethods.NullHandleRef);
NativeMethods.LOGFONT lf = new NativeMethods.LOGFONT();
Graphics graphics = Graphics.FromHdcInternal(screenDC);
try {
Font.ToLogFont(lf, graphics);
}
finally {
graphics.Dispose();
}
UnsafeNativeMethods.ReleaseDC(NativeMethods.NullHandleRef, new HandleRef(null, screenDC));
IntPtr logFontPtr = IntPtr.Zero;
try {
logFontPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(NativeMethods.LOGFONT)));
Marshal.StructureToPtr(lf, logFontPtr, false);
cf.lStructSize = Marshal.SizeOf(typeof(NativeMethods.CHOOSEFONT));
cf.hwndOwner = hWndOwner;
cf.hDC = IntPtr.Zero;
cf.lpLogFont = logFontPtr;
cf.Flags = Options | NativeMethods.CF_INITTOLOGFONTSTRUCT | NativeMethods.CF_ENABLEHOOK;
if (minSize > 0 || maxSize > 0)
{
cf.Flags |= NativeMethods.CF_LIMITSIZE;
}
//if ShowColor=true then try to draw the sample text in color,
//if ShowEffects=false then we will draw the sample text in standard control text color regardless.
//(limitation of windows control)
//
if (ShowColor || ShowEffects)
{
cf.rgbColors = ColorTranslator.ToWin32(color);
}
else
{
cf.rgbColors = ColorTranslator.ToWin32(SystemColors.ControlText);
}
cf.lpfnHook = hookProcPtr;
cf.hInstance = UnsafeNativeMethods.GetModuleHandle(null);
cf.nSizeMin = minSize;
if (maxSize == 0)
{
cf.nSizeMax = int.MaxValue;
}
else
{
cf.nSizeMax = maxSize;
}
Debug.Assert(cf.nSizeMin <= cf.nSizeMax, "min and max font sizes are the wrong way around");
if (!SafeNativeMethods.ChooseFont(cf))
{
return(false);
}
NativeMethods.LOGFONT lfReturned = null;
lfReturned = (NativeMethods.LOGFONT)UnsafeNativeMethods.PtrToStructure(logFontPtr, typeof(NativeMethods.LOGFONT));
if (lfReturned.lfFaceName != null && lfReturned.lfFaceName.Length > 0)
{
lf = lfReturned;
UpdateFont(lf);
UpdateColor(cf.rgbColors);
}
return(true);
}
finally {
if (logFontPtr != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(logFontPtr);
}
}
}
// returns the value of the corresponding text attribute
private static object GetStrikethroughStyle(NativeMethods.LOGFONT logfont)
{
return(logfont.lfStrikeOut != 0 ? TextDecorationLineStyle.Single : TextDecorationLineStyle.None);
}
