public static string GetFontFaceName(string fn) { Font ft = new Font(fn, 9F); LOGFONT lt = new LOGFONT(); ft.ToLogFont(lt); return lt.lfFaceName; }
/// <summary> /// Creates a font object that matches the properties specified by the LOGFONT structure. /// </summary> /// <param name="font">A <see cref="System.Drawing.Font"/> description. </param> /// <returns>a reference to a newly created <see cref="SharpDX.DirectWrite.Font"/>. </returns> /// <unmanaged>HRESULT IDWriteGdiInterop::CreateFontFromLOGFONT([In] const LOGFONTW* logFont,[Out] IDWriteFont** font)</unmanaged> public Font FromSystemDrawingFont(System.Drawing.Font font) { var logfontw = new Win32Native.LogFont(); font.ToLogFont(logfontw); return(FromLogFont(logfontw)); }
public void SetFont(Font font) { var lf = new LogFont(); font.ToLogFont(lf); lf.lfPitchAndFamily = FIXED_PITCH | FF_MODERN; NativeMethods.SendMessage(hIMEWnd, (int) WindowMessage.WM_IME_CONTROL, IMC_SETCOMPOSITIONFONT, lf); }
private static IntPtr CreateFontObject(Font font, bool antiAliasing) { NativeStructs.LOGFONT logFont = new NativeStructs.LOGFONT(); font.ToLogFont(logFont); int nHeight = logFont.lfHeight; int nWidth = logFont.lfWidth; int nEscapement = logFont.lfEscapement; int nOrientation = logFont.lfOrientation; int fnWeight = logFont.lfWeight; uint fdwItalic = logFont.lfItalic; uint fdwUnderline = logFont.lfUnderline; uint fdwStrikeOut = logFont.lfStrikeOut; uint fdwCharSet = logFont.lfCharSet; uint fdwOutputPrecision = logFont.lfOutPrecision; uint fdwClipPrecision = logFont.lfClipPrecision; uint fdwQuality; if (antiAliasing) { fdwQuality = NativeConstants.ANTIALIASED_QUALITY; } else { fdwQuality = NativeConstants.NONANTIALIASED_QUALITY; } uint fdwPitchAndFamily = logFont.lfPitchAndFamily; string lpszFace = logFont.lfFaceName; IntPtr hFont = SafeNativeMethods.CreateFontW( nHeight, nWidth, nEscapement, nOrientation, fnWeight, fdwItalic, fdwUnderline, fdwStrikeOut, fdwCharSet, fdwOutputPrecision, fdwClipPrecision, fdwQuality, fdwPitchAndFamily, lpszFace); if (hFont == IntPtr.Zero) { NativeMethods.ThrowOnWin32Error("CreateFontW returned NULL"); } return hFont; }
private static System.IntPtr CreateFont(System.Drawing.Font font) { Skybound.Windows.Forms.TextRenderer.LOGFONT logfont2; logfont2 = new Skybound.Windows.Forms.TextRenderer.LOGFONT(); object obj = logfont2; font.ToLogFont(obj); Skybound.Windows.Forms.TextRenderer.LOGFONT logfont1 = (Skybound.Windows.Forms.TextRenderer.LOGFONT)obj; logfont1.lfFaceName = font.Name; logfont1.lfQuality = 0; return(Skybound.Windows.Forms.TextRenderer.CreateFontIndirect(ref logfont1)); }
private void SetIMEWindowFont(System.Drawing.Font f) { if (Ime.disableIME || this.hIMEWnd == IntPtr.Zero) { return; } if (this.lf == null) { this.lf = new Ime.LOGFONT(); f.ToLogFont(this.lf); this.lf.lfFaceName = f.Name; } try { Ime.SendMessage(this.hIMEWnd, 643, new IntPtr(10), this.lf); } catch (AccessViolationException accessViolationException) { this.Handle(accessViolationException); } }
public void ToLogFont_TooSmall () { Font f = new Font ("Arial", 10); object o = new object (); f.ToLogFont (o); // no PInvoke conversion exists !?!? }
public void ToLogFont_AssertUnmanagedCode () { Font f = new Font("Arial", 10); LOGFONT lf = new LOGFONT(); f.ToLogFont (lf); Assert.AreEqual (400, lf.lfWeight, "lfWeight"); Assert.AreEqual (1, lf.lfCharSet, "lfCharSet"); Assert.AreEqual (f.Name, lf.lfFaceName, "lfFaceName"); LOGFONT_STRUCT lfs = new LOGFONT_STRUCT (); f.ToLogFont (lfs); Assert.AreEqual (0, lfs.lfWeight, "struct-lfWeight"); Assert.AreEqual (0, lfs.lfCharSet, "struct-lfCharSet"); Assert.AreEqual (0, lfs.lfHeight, "struct-lfHeight"); Assert.AreEqual (0, lfs.lfWidth, "struct-lfWidth"); Assert.AreEqual (0, lfs.lfEscapement, "struct-lfEscapement"); Assert.AreEqual (0, lfs.lfOrientation, "struct-lfOrientation"); Assert.AreEqual (0, lfs.lfWeight, "struct-lfWeight"); Assert.AreEqual (0, lfs.lfItalic, "struct-lfItalic"); Assert.AreEqual (0, lfs.lfUnderline, "struct-lfUnderline"); Assert.AreEqual (0, lfs.lfStrikeOut, "struct-lfStrikeOut"); Assert.AreEqual (0, lfs.lfCharSet, "struct-lfCharSet"); Assert.AreEqual (0, lfs.lfOutPrecision, "struct-lfOutPrecision"); Assert.AreEqual (0, lfs.lfClipPrecision, "struct-lfClipPrecision"); Assert.AreEqual (0, lfs.lfQuality, "struct-lfQuality"); Assert.AreEqual (0, lfs.lfPitchAndFamily, "struct-lfPitchAndFamily"); Assert.IsNull (lfs.lfFaceName, "struct-lfFaceName"); }
public void ToLogFont_DenyUnmanagedCode () { Font f; LOGFONT lf; lf = new LOGFONT(); f = new Font("Arial", 10); f.ToLogFont(lf); }
public static void GetLogFont(Font font, Graphics graphics, out LOGFONT logfont) { object o = new LOGFONT(); if (graphics != null) { font.ToLogFont(o, graphics); } else { font.ToLogFont(o); } logfont = (LOGFONT)o; }
private static NativeMethods.FONTDESC GetFONTDESCFromFont(Font font) { NativeMethods.FONTDESC fdesc = null; if (fontTable == null) { fontTable = new Hashtable(); } else { fdesc = (NativeMethods.FONTDESC)fontTable[font]; } if (fdesc == null) { fdesc = new NativeMethods.FONTDESC(); fdesc.lpstrName = font.Name; fdesc.cySize = (long)(font.SizeInPoints * 10000); NativeMethods.LOGFONT logfont = new NativeMethods.LOGFONT(); font.ToLogFont(logfont); fdesc.sWeight = (short) logfont.lfWeight; fdesc.sCharset = logfont.lfCharSet; fdesc.fItalic = font.Italic; fdesc.fUnderline = font.Underline; fdesc.fStrikethrough = font.Strikeout; fontTable[font] = fdesc; } return fdesc; }
public void Dispose_ToLogFont () { #if !TARGET_JVM Font f = new Font (name, 12.5f); f.Dispose (); LOGFONT lf = new LOGFONT(); f.ToLogFont (lf); #endif }
public bool LoadSubtitles(IGraphBuilder graphBuilder, string filename) { FreeSubtitles(); LoadSettings(); { //remove InternalScriptRenderer as it takes subtitle pin IBaseFilter isr = null; DirectShowUtil.FindFilterByClassID(graphBuilder, ClassId.InternalScriptRenderer, out isr); if (isr != null) { graphBuilder.RemoveFilter(isr); DirectShowUtil.ReleaseComObject(isr); } } vobSub = (IDirectVobSub)DirectVobSubUtil.AddToGraph(graphBuilder); if (vobSub == null) return false; { //set style Log.Debug("VideoPlayerVMR9: Setting DirectVobsub parameters"); LOGFONT logFont = new LOGFONT(); int txtcolor; bool fShadow, fOutLine, fAdvancedRenderer = false; int size = Marshal.SizeOf(typeof(LOGFONT)); vobSub.get_TextSettings(logFont, size, out txtcolor, out fShadow, out fOutLine, out fAdvancedRenderer); FontStyle fontStyle = defStyle.fontIsBold ? FontStyle.Regular : FontStyle.Bold; Font Subfont = new Font(defStyle.fontName, defStyle.fontSize, fontStyle, GraphicsUnit.Point, (byte)defStyle.fontCharset); Subfont.ToLogFont(logFont); fShadow = defStyle.shadow > 0; fOutLine = defStyle.isBorderOutline; vobSub.put_TextSettings(logFont, size, defStyle.fontColor, fShadow, fOutLine, fAdvancedRenderer); vobSub.put_FileName(filename); bool fBuffer, fOnlyForced, fPolygonize; vobSub.get_VobSubSettings(out fBuffer, out fOnlyForced, out fPolygonize); vobSub.put_VobSubSettings(fBuffer, !this.autoShow, fPolygonize); } { //load sub streams IBaseFilter hms = null; DirectShowUtil.FindFilterByClassID(graphBuilder, ClassId.HaaliGuid, out hms); if (hms == null) DirectShowUtil.FindFilterByClassID(graphBuilder, ClassId.LAVFilterSource, out hms); if (hms == null) DirectShowUtil.FindFilterByClassID(graphBuilder, ClassId.LAVFilter, out hms); embeddedSelector = hms as IAMStreamSelect; if (embeddedSelector != null) { AddStreams(embeddedSelector); } vobSub.get_LanguageCount(out extCount); if (intSubs.Count > 0) { //if there are embedded subtitles, //last stream of directvobsub is currently selected embedded subtitle extCount--; } } FFDShowEngine.DisableFFDShowSubtitles(graphBuilder); Current = 0; if (selectionOff) { Enable = false; } else { Enable = autoShow; } return true; }
/// <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."); } } }
/// <summary> /// Determines whether a font uses the 'symbol' character set. /// </summary> /// <remarks> /// Symbol fonts do not typically contain glyphs that represent letters of the alphabet. /// Instead they might contain pictures and symbols. As such, they are not useful for /// drawing text. Which means you can't use a symbol font to write out its own name for /// illustrative purposes (like for the font drop-down chooser). /// </remarks> public static bool IsSymbolFont(Font font) { NativeStructs.LOGFONT logFont = new NativeStructs.LOGFONT(); font.ToLogFont(logFont); return logFont.lfCharSet == NativeConstants.SYMBOL_CHARSET; }
static private void FontToLogFont(Font value, NativeMethods.LOGFONT logfont) { value.ToLogFont(logfont); }
public static string GetFontFaceName(Font ft) { LOGFONT lt = new LOGFONT(); ft.ToLogFont(lt); return lt.lfFaceName; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="LogicalFont"/> class. /// </summary> /// <param name="createFrom">The font to use as the basis for the logical font.</param> /// <remarks>If it's not obvious why we need this class in order to determine if a font /// is a symbol font, see the Dr. Gui article entitled /// <see href="http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dnaraskdr/html/askgui12302003.asp"> /// Determining the Character Set Used by a Font</see></remarks> /// ------------------------------------------------------------------------------------ public LogicalFont(Font createFrom) { createFrom.ToLogFont(this); }
public void Dispose_ToLogFont () { Font f = new Font (name, 12.5f); f.Dispose (); LOGFONT lf = new LOGFONT(); f.ToLogFont (lf); }
public void ToLogFont_Int () { Font f = new Font ("Arial", 10); int i = 1; f.ToLogFont (i); Assert.AreEqual (1, i); }
public void ToLogFont_Null () { Font f = new Font ("Arial", 10); f.ToLogFont (null); }
protected override void OnCreateControl() { base.OnCreateControl(); // This hack tries to apply the Roboto (24) font to all ListViewItems in this ListView // It only succeeds if the font is installed on the system. // Otherwise, a default sans serif font is used. Font roboto24 = new Font(SkinManager.ROBOTO_MEDIUM_12.FontFamily, 24); LogFont roboto24logfont = new LogFont(); roboto24.ToLogFont(roboto24logfont); try { // Font.FromLogFont is the method used when drawing ListViewItems. I 'test' it in this safer context to avoid unhandled exceptions later. Font = Font.FromLogFont(roboto24logfont); } catch (ArgumentException) { Font = new Font(FontFamily.GenericSansSerif, 24); } }
public void Dispose_ToLogFont_LoopCharSet () { #if !TARGET_JVM Font f = new Font (name, 12.5f); f.Dispose (); LOGFONT lf = new LOGFONT (); for (int i = Byte.MinValue; i < Byte.MaxValue; i++) { byte b = (byte) i; lf.lfHeight = b; lf.lfWidth = b; lf.lfEscapement = b; lf.lfOrientation = b; lf.lfWeight = b; lf.lfItalic = b; lf.lfUnderline = b; lf.lfStrikeOut = b; lf.lfCharSet = b; lf.lfOutPrecision = b; lf.lfClipPrecision = b; lf.lfQuality = b; lf.lfPitchAndFamily = b; lf.lfFaceName = b.ToString (); try { f.ToLogFont (lf); } catch (ArgumentException) { Assert.AreEqual (b, lf.lfHeight, "lfHeight"); Assert.AreEqual (b, lf.lfWidth, "lfWidth"); Assert.AreEqual (b, lf.lfEscapement, "lfEscapement"); Assert.AreEqual (b, lf.lfOrientation, "lfOrientation"); Assert.AreEqual (b, lf.lfWeight, "lfWeight"); Assert.AreEqual (b, lf.lfItalic, "lfItalic"); Assert.AreEqual (b, lf.lfUnderline, "lfUnderline"); Assert.AreEqual (b, lf.lfStrikeOut, "lfStrikeOut"); // special case for 0 Assert.AreEqual ((i == 0) ? (byte)1 : b, lf.lfCharSet, "lfCharSet"); Assert.AreEqual (b, lf.lfOutPrecision, "lfOutPrecision"); Assert.AreEqual (b, lf.lfClipPrecision, "lfClipPrecision"); Assert.AreEqual (b, lf.lfQuality, "lfQuality"); Assert.AreEqual (b, lf.lfPitchAndFamily, "lfPitchAndFamily"); Assert.AreEqual (b.ToString (), lf.lfFaceName, "lfFaceName"); } catch (Exception e) { Assert.Fail ("Unexcepted exception {0} at iteration {1}", e, i); } } #endif }
private void SetIMEWindowFont(Font f) { if (disableIME || hIMEWnd == IntPtr.Zero) return; if (lf == null) { lf = new LOGFONT(); f.ToLogFont(lf); lf.lfFaceName = f.Name; // This is very important! "Font.ToLogFont" Method sets invalid value to LOGFONT.lfFaceName } try { SendMessage(hIMEWnd, WM_IME_CONTROL, new IntPtr(IMC_SETCOMPOSITIONFONT), lf ); } catch (AccessViolationException ex) { Handle(ex); } }
private void SetIMEWindowFont(Font f) { LOGFONT lf = new LOGFONT(); f.ToLogFont(lf); lf.lfPitchAndFamily = FIXED_PITCH | FF_MODERN; SendMessage( hIMEWnd, WM_IME_CONTROL, IMC_SETCOMPOSITIONFONT, lf ); }
private void SetIMEWindowFont(Font f) { if (lf == null) { lf = new LOGFONT(); f.ToLogFont(lf); lf.lfFaceName = f.Name; // This is very important! "Font.ToLogFont" Method sets invalid value to LOGFONT.lfFaceName } SendMessage( hIMEWnd, WM_IME_CONTROL, new IntPtr(IMC_SETCOMPOSITIONFONT), lf ); }
public static IntPtr CreateNormalHFont(Font font, int width) { LOGFONT logf = new LOGFONT(); font.ToLogFont(logf); logf.lfWidth = width; logf.lfOutPrecision = (byte)FontPrecision.OUT_TT_ONLY_PRECIS; var ret = CreateFontIndirect(logf); return ret; }
// Returns whether or not target was changed internal static bool FontToIFont(Font source, UnsafeNativeMethods.IFont target) { bool changed = false; // we need to go through all the pain of the diff here because // it looks like setting them all has different results based on the // order and each individual IFont implementor... // string fontName = target.GetName(); if (!source.Name.Equals(fontName)) { target.SetName(source.Name); changed = true; } // [....], Review: this always seems to come back as // the point size * 10000 (HIMETRIC?), regardless // or ratio or mapping mode, and despite what // the documentation says... // // Either figure out what's going on here or // do the process that the windows forms FONT object does here // or, worse case, just create another Font object // from the handle, but that's pretty heavy... // float fontSize = (float)target.GetSize() / 10000; // size must be in points float winformsSize = source.SizeInPoints; if (winformsSize != fontSize) { target.SetSize((long)(winformsSize * 10000)); changed = true; } NativeMethods.LOGFONT logfont = new NativeMethods.LOGFONT(); IntSecurity.ObjectFromWin32Handle.Assert(); try { source.ToLogFont(logfont); } finally { CodeAccessPermission.RevertAssert(); } short fontWeight = target.GetWeight(); if (fontWeight != logfont.lfWeight) { target.SetWeight((short)logfont.lfWeight); changed = true; } bool fontBold = target.GetBold(); if (fontBold != (logfont.lfWeight >= 700)) { target.SetBold(logfont.lfWeight >= 700); changed = true; } bool fontItalic = target.GetItalic(); if (fontItalic != (0 != logfont.lfItalic)) { target.SetItalic(0 != logfont.lfItalic); changed = true; } bool fontUnderline = target.GetUnderline(); if (fontUnderline != (0 != logfont.lfUnderline)) { target.SetUnderline(0 != logfont.lfUnderline); changed = true; } bool fontStrike = target.GetStrikethrough(); if (fontStrike != (0 != logfont.lfStrikeOut)) { target.SetStrikethrough(0 != logfont.lfStrikeOut); changed = true; } short fontCharset = target.GetCharset(); if (fontCharset != logfont.lfCharSet) { target.SetCharset(logfont.lfCharSet); changed = true; } return changed; }
internal static bool FontToIFont(Font source, System.Windows.Forms.UnsafeNativeMethods.IFont target) { bool flag = false; string name = target.GetName(); if (!source.Name.Equals(name)) { target.SetName(source.Name); flag = true; } float num = ((float) target.GetSize()) / 10000f; float sizeInPoints = source.SizeInPoints; if (sizeInPoints != num) { target.SetSize((long) (sizeInPoints * 10000f)); flag = true; } System.Windows.Forms.NativeMethods.LOGFONT logFont = new System.Windows.Forms.NativeMethods.LOGFONT(); System.Windows.Forms.IntSecurity.ObjectFromWin32Handle.Assert(); try { source.ToLogFont(logFont); } finally { CodeAccessPermission.RevertAssert(); } if (target.GetWeight() != logFont.lfWeight) { target.SetWeight((short) logFont.lfWeight); flag = true; } if (target.GetBold() != (logFont.lfWeight >= 700)) { target.SetBold(logFont.lfWeight >= 700); flag = true; } if (target.GetItalic() != (0 != logFont.lfItalic)) { target.SetItalic(0 != logFont.lfItalic); flag = true; } if (target.GetUnderline() != (0 != logFont.lfUnderline)) { target.SetUnderline(0 != logFont.lfUnderline); flag = true; } if (target.GetStrikethrough() != (0 != logFont.lfStrikeOut)) { target.SetStrikethrough(0 != logFont.lfStrikeOut); flag = true; } if (target.GetCharset() != logFont.lfCharSet) { target.SetCharset(logFont.lfCharSet); flag = true; } return flag; }
//this returns an IntPtr HFONT because .net's Font class will erase the relevant properties when using its Font.FromLogFont() //note that whether this is rotated clockwise or CCW might affect how you have to position the text (right-aligned sometimes?, up or down by the height of the font?) public static IntPtr CreateRotatedHFont(Font font, bool CW) { LOGFONT logf = new LOGFONT(); font.ToLogFont(logf); logf.lfEscapement = CW ? 2700 : 900; logf.lfOrientation = logf.lfEscapement; logf.lfOutPrecision = (byte)FontPrecision.OUT_TT_ONLY_PRECIS; //this doesnt work! .net erases the relevant propreties.. it seems? //return Font.FromLogFont(logf); var ret = CreateFontIndirect(logf); return ret; }