It is Clear[Type] how the quality is being managed

Lots of people have pointed out both before and after I did in When a user sets something. please assume they meant it how unfortunate it is that so many different applications and processes turn on ClearType whether the user wants it on or not.

Well, just as I previously talked about how the design of IsNLSDefinedString was actually a a bit of an exercise in social engineering, the unfortunate fact is the documentation about ClearType and its pointers to the fdwQuality parameter in the CreateFont function and the lfQuality member of the LOGFONT structure make it really easy to decide what you want the behavior to be:

Value	Meaning
ANTIALIASED_QUALITY	Windows NT 4.0 and later: Font is antialiased, or smoothed, if the font supports it and the size of the font is not too small or too large. Windows 95 with Plus!, Windows 98/Me: The display must greater than 8-bit color, it must be a single plane device, it cannot be a palette display, and it cannot be in a multiple display monitor setup. In addition, you must select a TrueType font into a screen DC prior to using it in a DIBSection, otherwise antialiasing does not happen.
CLEARTYPE_QUALITY	Windows XP: If set, text is rendered (when possible) using ClearType antialiasing method. See Remarks for more information.
DEFAULT_QUALITY	Appearance of the font does not matter.
DRAFT_QUALITY	Appearance of the font is less important than when the PROOF_QUALITY value is used. For GDI raster fonts, scaling is enabled, which means that more font sizes are available, but the quality may be lower. Bold, italic, underline, and strikeout fonts are synthesized, if necessary.
NONANTIALIASED_QUALITY	Windows 95 with Plus!, Windows 98/Me, Windows NT 4.0 and later: Font is never antialiased, that is, font smoothing is not done.
PROOF_QUALITY	Character quality of the font is more important than exact matching of the logical-font attributes. For GDI raster fonts, scaling is disabled and the font closest in size is chosen. Although the chosen font size may not be mapped exactly when PROOF_QUALITY is used, the quality of the font is high and there is no distortion of appearance. Bold, italic, underline, and strikeout fonts are synthesized, if necessary.

Looking at wingdi.h, the values behind these constants are:

#define DEFAULT_QUALITY 0
#define DRAFT_QUALITY 1
#define PROOF_QUALITY 2
#if(WINVER >= 0x0400)
#define NONANTIALIASED_QUALITY 3
#define ANTIALIASED_QUALITY 4
#endif /* WINVER >= 0x0400 */

#if (_WIN32_WINNT >= _WIN32_WINNT_WINXP)
#define CLEARTYPE_QUALITY 5
#define CLEARTYPE_NATURAL_QUALITY 6
#endif

Yes, there is that extra CLEARTYPE_NATURAL_QUALITY constant which is defined in the header file and documented all over creation except on MSDN right now. Good luck trying to determine what it means. :-)

The method that anyone who wants to ignore the user setting will use is to jut pass a different value in the fonts that are created....

And what about managed code?

Well, the truth is that GDI+ does not define any of this stuff in its font creation, as code like this shows:

using System;
using System.Drawing;
using System.Runtime.InteropServices;

namespace FontStuff {
  class test {

    private unsafe struct LOGFONT {
      public int lfHeight;
      public int lfWidth;
      public int lfEscapement;
      public int lfOrientation;
      public int lfWeight;
      public byte lfItalic;
      public byte lfUnderline;
      public byte lfStrikeOut;
      public byte lfCharSet;
      public byte lfOutPrecision;
      public byte lfClipPrecision;
      public QUALITY lfQuality;
      public byte lfPitchAndFamily;
      public fixed char lfFaceName[32];
    };

    private enum QUALITY : byte {
      DEFAULT_QUALITY = 0,
      DRAFT_QUALITY = 1,
      PROOF_QUALITY = 2,
      NONANTIALIASED_QUALITY = 3,
      ANTIALIASED_QUALITY = 4,
      CLEARTYPE_QUALITY = 5,
      CLEARTYPE_NATURAL_QUALITY = 6
    }

    [DllImport("gdi32.dll", CharSet=CharSet.Unicode, ExactSpelling=true, CallingConvention=CallingConvention.StdCall)]
    private static extern int GetObjectW(IntPtr hgdiobj, int cbBuffer, out LOGFONT lpvObject); 

    [DllImport("gdi32.dll", CharSet=CharSet.Unicode, ExactSpelling=true, CallingConvention=CallingConvention.StdCall)]
    private static extern IntPtr CreateFontIndirectW(ref LOGFONT lplf);

    [DllImport("gdi32.dll", ExactSpelling=true, CallingConvention=CallingConvention.StdCall)]
    private static extern bool DeleteObject(IntPtr hObject);

    [STAThread]
    static void Main(string[] args) {
      if(args.Length != 1) {
        Console.WriteLine("You have to give a font name.");
      } else {
        Font fnt = new Font(args[0], 9);
        IntPtr hFont = fnt.ToHfont();
        LOGFONT lf = new LOGFONT();
        if(GetObjectW(hFont, Marshal.SizeOf(lf), out lf) != 0) {
          Console.WriteLine("The GDI+ lfQuality of '{0}' is {1}.", args[0], lf.lfQuality);

          lf.lfQuality = QUALITY.CLEARTYPE_QUALITY;
          IntPtr hFont2 = CreateFontIndirectW(ref lf);
          if(hFont2 != IntPtr.Zero) {
            Font fnt2 = Font.FromHfont(hFont2);
            IntPtr hFont3 = fnt.ToHfont();
            LOGFONT lf2 = new LOGFONT();
            if(GetObjectW(hFont3, Marshal.SizeOf(lf2), out lf2) != 0) {
              Console.WriteLine("The modified GDI+ lfQuality of '{0}' is {1}.", args[0], lf2.lfQuality);
            }
          }
          DeleteObject(hFont2);
        }
      }
    }
  }
}

It will pretty much always return DEFAULT_QUALITY for any font created from GDI+ even if it is created with a ClearType-enabled font on the Win32 side. And the same thing will happen with any font that heads through GDI+. This makes it much harder to actually translate ClearType usage across the managed/unmanaged boundary of GDI/GDI+.

To get ClearType support within GDI+, as the MSDN help topic Antialiasing with Text indicates, you have to set the Graphics.TextRenderingHint property to one of the members of the TextRenderingHint enumeration.

The docs are not entirely clear on the point though, because even though they say things like

The quality ranges from text (fastest performance, but lowest quality) to antialiased text (better quality, but slower performance) to ClearType text (best quality on an LCD display).

the actual values behind the enumeration are not given, and the members are listed alphabetically rather than by any kind of range order. The actual ordered list, values 0 to 5, would be:

• SystemDefault
• SingleBitPerPixelGridFit
• SingleBitPerPixel
• AntiAliasGridFit
• AntiAlias
• ClearTypeGridFit

Now this list does not seem to be in any kind of range order either, for what its worth. :-)

Though by making it a setting to make for each Graphics object rather than each font, it is perhaps a bit less common to actually change the value from what the system wants. It is a subtle difference, but in the end you are hopefully much more likely to see (for example) WinForms applications follow the system settings. Thank goodness for small favors.

Now Avalon (WPF) does this an entirely different way, and I will have to talk about that another day....

This post brought to you by ⎚ (U+239a, a.k.a. CLEAR SCREEN SYMBOL)