Source

fontquery / fontquery.py

Full commit
"""
Query system Windows fonts from Python.

The task: Get monospace font for an application in the order of
preference.

The problem: Font ID in Windows is its name. Windows doesn't provide
any information about filenames they contained in. From two different
files with the same font name you'll can get only one.

[ ] Windows also doesn't allow getting only monospace fonts. You need
to query all available fonts and filter them yourself.

Use cases:
 [ ] get the list of all system fonts available
 [ ] get the list of families available
 [ ] get the list of all fonts for specific family
 [ ] check if specific font is available
   [ ] check that family matched if another font is returned

Considerations:
 - performance of querying all system fonts is not measured
 - Windows doesn't allow to get filenames of the fonts, so if there
   are two fonts with the same name, one will be missing

MSDN:

    If you request a font named Palatino, but no such font is available
on the system, the font mapper will substitute a font that has similar
attributes but a different name.

    To get the appropriate font, call EnumFontFamiliesEx with the
desired font characteristics in the LOGFONT structure, then retrieve the
appropriate typeface name and create the font using CreateFont or
CreateFontIndirect.

Wikipedia:

    Because of the additional text processing and resolution independence
capabilities in GDI+, text rendering is performed by the CPU [2] and it
is nearly an order of magnitude slower than in hardware accelerated GDI.[3]
Chris Jackson published some tests indicating that a piece of text
rendering code he had written could render 99,000 glyphs per second in GDI,
but the same code using GDI+ rendered 16,600 glyphs per second.

"""

#-- CHAPTER 1: GET ALL SYSTEM FONTS USING EnumFontFamiliesEx FROM GDI --
#
# Essential info about font metrics http://support.microsoft.com/kb/32667
# And about logical units at http://www.winprog.org/tutorial/fonts.html

import ctypes
from ctypes import wintypes

user32 = ctypes.windll.user32
gdi32 = ctypes.windll.gdi32

# --- define necessary data structures from wingdi.h

# for calling ANSI functions of Windows API (end with A) TCHAR is
# defined as single char, for Unicode ones (end witn W) it is WCHAR
TCHAR = wintypes.CHAR
BYTE = ctypes.c_ubyte   # http://bugs.python.org/issue16376

# charset codes for LOGFONT structure
ANSI_CHARSET    = 0
ARABIC_CHARSET  = 178
BALTIC_CHARSET  = 186
CHINESEBIG5_CHARSET = 136
DEFAULT_CHARSET = 1
  # - charset for current system locale -
  #   means function can be called several times
  #   for the single font (for each charset)
EASTEUROPE_CHARSET = 238
GB2312_CHARSET = 134
GREEK_CHARSET  = 161
HANGUL_CHARSET = 129
HEBREW_CHARSET = 177
JOHAB_CHARSET  = 130
MAC_CHARSET = 77
OEM_CHARSET = 255  # OS dependent system charset
RUSSIAN_CHARSET  = 204
SHIFTJIS_CHARSET = 128
SYMBOL_CHARSET   = 2
THAI_CHARSET     = 222
TURKISH_CHARSET  = 162
VIETNAMESE_CHARSET = 163

# build lookup dictionary to get charset name from its code
CHARSET_NAMES = {}
for (name, value) in locals().copy().items():
  if name.endswith('_CHARSET'):
    CHARSET_NAMES[value] = name


class LOGFONT(ctypes.Structure):
  # EnumFontFamiliesEx examines only 3 fields:
  #  - lfCharSet
  #  - lfFaceName  - empty string enumerates one font in each available
  #                  typeface name, valid typeface name gets all fonts
  #                  with that name
  #  - lfPitchAndFamily - must be set to 0 [ ]
  _fields_ = [
    ('lfHeight', wintypes.LONG),
      # value > 0  specifies the largest size of *char cell* to match
      #            char cell = char height + internal leading
      # value = 0  makes matched use default height for search
      # value < 0  specifies the largest size of *char height* to match
    ('lfWidth',  wintypes.LONG),
      # average width also in *logical units*, which are pixels in
      # default _mapping mode_ (MM_TEXT) for device
    ('lfEscapement',  wintypes.LONG),
      # string baseline rotation in tenths of degrees
    ('lfOrientation', wintypes.LONG),
      # character rotation in tenths of degrees
    ('lfWeight', wintypes.LONG),
      # 0 through 1000  400 is normal, 700 is bold, 0 is default
    ('lfItalic', BYTE),
    ('lfUnderline', BYTE),
    ('lfStrikeOut', BYTE),
    ('lfCharSet',   BYTE),
      # ANSI_CHARSET, BALTIC_CHARSET, ... - see *_CHARSET constants above
    ('lfOutPrecision', BYTE),
      # many constants how the output must match height, width, pitch etc.
      # OUT_DEFAULT_PRECIS
      # [ ] TODO
    ('lfClipPrecision', BYTE),
      # how to clip characters, no useful properties, leave default value
      # CLIP_DEFAULT_PRECIS
    ('lfQuality', BYTE),
      # ANTIALIASED_QUALITY
      # CLEARTYPE_QUALITY
      # DEFAULT_QUALITY 
      # DRAFT_QUALITY
      # NONANTIALIASED_QUALITY
      # PROOF_QUALITY
    ('lfPitchAndFamily', BYTE),
      # DEFAULT_PITCH
      # FIXED_PITCH
      # VARIABLE_PITCH
      #    stacked any of with
      # FF_DECORATIVE   - novelty
      # FF_DONTCARE     - default font
      # FF_MODERN       - monospace
      # FF_ROMAN        - proportional (variable char width) with serifs
      # FF_SCRIPT       - handwritten
      # FF_SWISS        - proportional without serifs
    ('lfFaceName', TCHAR*32)]
      # typeface name of the font - null-terminated string

class FONTSIGNATURE(ctypes.Structure):
  # supported code pages and Unicode subranges for the font
  # needed for NEWTEXTMETRICEX structure
  _fields_ = [
    ('sUsb', wintypes.DWORD*4),  # 128-bit Unicode subset bitfield (USB)
    ('sCsb', wintypes.DWORD*2)]  # 64-bit, code-page bitfield (CPB)

class NEWTEXTMETRIC(ctypes.Structure):
  # physical font attributes for True Type fonts
  # needed for NEWTEXTMETRICEX structure
  _fields_ = [
    ('tmHeight', wintypes.LONG),
    ('tmAscent', wintypes.LONG),
    ('tmDescent', wintypes.LONG),
    ('tmInternalLeading', wintypes.LONG),
    ('tmExternalLeading', wintypes.LONG),
    ('tmAveCharWidth', wintypes.LONG),
    ('tmMaxCharWidth', wintypes.LONG),
    ('tmWeight', wintypes.LONG),
    ('tmOverhang', wintypes.LONG),
    ('tmDigitizedAspectX', wintypes.LONG),
    ('tmDigitizedAspectY', wintypes.LONG),
    ('mFirstChar', TCHAR),
    ('mLastChar', TCHAR),
    ('mDefaultChar', TCHAR),
    ('mBreakChar', TCHAR),
    ('tmItalic', BYTE),
    ('tmUnderlined', BYTE),
    ('tmStruckOut', BYTE),
    ('tmPitchAndFamily', BYTE),
    ('tmCharSet', BYTE),
    ('tmFlags', wintypes.DWORD),
    ('ntmSizeEM', wintypes.UINT),
    ('ntmCellHeight', wintypes.UINT),
    ('ntmAvgWidth', wintypes.UINT)]

class NEWTEXTMETRICEX(ctypes.Structure):
  # physical font attributes for True Type fonts
  # needed for FONTENUMPROC callback function
  _fields_ = [
    ('ntmTm', NEWTEXTMETRIC),
    ('ntmFontSig', FONTSIGNATURE)]


# type for a function that is called by the system for
# each font during execution of EnumFontFamiliesEx
FONTENUMPROC = ctypes.WINFUNCTYPE(
  ctypes.c_int,  # return non-0 to continue enumeration, 0 to stop
  ctypes.POINTER(LOGFONT), 
  ctypes.POINTER(NEWTEXTMETRICEX),
  wintypes.DWORD,  # font type, a combination of
                   #   DEVICE_FONTTYPE
                   #   RASTER_FONTTYPE 
                   #   TRUETYPE_FONTTYPE 
  wintypes.LPARAM
);

def enumerator(logfont, textmetricex, fonttype, param):
  lf = logfont.contents
  print(lf.lfFaceName)
  return 1

fontenumproc = FONTENUMPROC(enumerator)

# --- /define


# --- prepare and call EnumFontFamiliesEx

def query():
  # 1. Get device context of the entire screen
  hdc = user32.GetDC(None)

  # 2. Call EnumFontFamiliesExA (ANSI version)

  # [r] font name should be less than 32 symbols
  # [ ] check empty name and DEFAULT_CHARSET - how many time a font is
  #     returned
  # [ ] check double purpose - enumerate all available font names
  #      - enumerate all available charsets for a single font
  #      - other params?
  logfont = LOGFONT(0, 0, 0, 0, 0, 0, 0, 0,
                    0x0,
                    0, 0, 0, 0, b'\0')
  res = gdi32.EnumFontFamiliesExA(
          hdc,   # handle to device context
          ctypes.byref(logfont),
          fontenumproc, # pointer to callback function
          0,  # lParam  - application-supplied data
          0)  # dwFlags - reserved = 0
  # res here is the last value returned by callback function

  # 3. Release DC
  user32.ReleaseDC(None, hdc)

query()

# x. Convert desired font size from points into logical units (pixels)

# By default logical for the screen units are pixels. This is defined
# by default MM_TEXT mapping mode.

# Point is ancient unit of measurement for physical size of a font.
# 10pt is equal to 3.527mm. To make sure a char on screen has physical
# size equal to 3.527mm, we need to know display size to calculate how
# many pixels are in 3.527mm, and then fetch font that best matches
# this size.

# Essential info about conversion http://support.microsoft.com/kb/74299

# x.1 Get pixels per inch using GetDeviceCaps() or ...


# y. Font object with several layers of info

# Font object should contains normalized font information. This
# information is split according to usage. For example, level 0 property
# is font id - its name. Level 1 can be information about loaded font
# characters - in pyglet it could be cached/used glyphs and video memory
# taken by those glyphs.

# [ ] (pyglet) investigate if it is possible to get video memory size
#              occupied by the font glyphs

# [ ] (pyglet) investigate if it is possible to unload font from video
#              memory if its unused