522 lines
16 KiB
Python
522 lines
16 KiB
Python
"""
|
|
Query system Windows fonts with pure Python.
|
|
|
|
Public domain work by anatoly techtonik <techtonik@gmail.com>
|
|
Use MIT License if public domain doesn't make sense for you.
|
|
|
|
|
|
|
|
The task: Get monospace font for an application in the order of
|
|
preference.
|
|
|
|
A 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 can get only one.
|
|
|
|
Windows also doesn't have a clear concept of _generic font family_
|
|
familiar from CSS specification. Here is how fontquery maps Windows
|
|
LOGFONT properties to generic CSS font families:
|
|
|
|
serif - (LOGFONT.lfPitchAndFamily >> 4) == FF_ROMAN
|
|
sans-serif - (LOGFONT.lfPitchAndFamily >> 4) == FF_SWISS
|
|
cursive - (LOGFONT.lfPitchAndFamily >> 4) == FF_SCRIPT
|
|
fantasy - (LOGFONT.lfPitchAndFamily >> 4) == FF_DECORATIVE
|
|
monospace - (lf.lfPitchAndFamily & 0b11) == FIXED_PITCH
|
|
|
|
NOTE: ATM, May 2015, the Microsoft documentation related to monospace
|
|
is misleading due to poor wording:
|
|
- FF_MODERN in the description of LOGFONT structure tells
|
|
"Fonts with constant stroke width (monospace), with or without serifs.
|
|
Monospace fonts are usually modern.
|
|
Pica, Elite, and CourierNew are examples.
|
|
"
|
|
|
|
Stroke width is the 'pen width', not glyph width. It should read
|
|
|
|
"Fonts with constant stroke width, with or without serifs.
|
|
Monospace fonts are usually modern, but not all modern are monospace
|
|
"
|
|
|
|
PYGLET NOTE:
|
|
Examination of all fonts in a windows xp machine shows that all fonts
|
|
with
|
|
|
|
fontentry.vector and fontentry.family != FF_DONTCARE
|
|
|
|
are rendered fine.
|
|
|
|
|
|
Use cases:
|
|
[x] get the list of all available system font names
|
|
[ ] get the list of all fonts for generic family
|
|
[ ] get the list of all fonts for specific charset
|
|
[ ] check if specific font is available
|
|
|
|
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.
|
|
|
|
[ ] check if font chosen by the system has required family
|
|
|
|
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.
|
|
|
|
"""
|
|
from pyglet.libs.win32.context_managers import device_context
|
|
|
|
DEBUG = False
|
|
|
|
__all__ = ['have_font', 'font_list']
|
|
|
|
__version__ = '0.3'
|
|
__url__ = 'https://bitbucket.org/techtonik/fontquery'
|
|
|
|
|
|
# -- INTRO: MAINTAIN CACHED FONTS DB --
|
|
|
|
# [ ] make it Django/NDB style model definition
|
|
class FontEntry:
|
|
"""
|
|
Font classification.
|
|
Level 0:
|
|
- name
|
|
- vector (True if font is vector, False for raster fonts)
|
|
- format: ttf | ...
|
|
"""
|
|
|
|
def __init__(self, name, vector, format, monospace, family):
|
|
self.name = name
|
|
self.vector = vector
|
|
self.format = format
|
|
self.monospace = monospace
|
|
self.family = family
|
|
|
|
|
|
# List of FontEntry objects
|
|
FONTDB = []
|
|
|
|
# -- CHAPTER 1: GET ALL SYSTEM FONTS USING EnumFontFamiliesEx FROM GDI --
|
|
|
|
"""
|
|
Q: Why GDI? Why not GDI+?
|
|
A: 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.
|
|
"""
|
|
|
|
import ctypes
|
|
from ctypes import wintypes
|
|
from pyglet.libs.win32 import LOGFONT, LOGFONTW
|
|
|
|
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
|
|
CHAR = ctypes.c_char # Python 2.7 compatibility
|
|
TCHAR = 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
|
|
|
|
# font pitch constants ('fixed pitch' means 'monospace')
|
|
DEFAULT_PITCH = 0
|
|
FIXED_PITCH = 1
|
|
VARIABLE_PITCH = 2
|
|
|
|
# Windows font family constants
|
|
FF_DONTCARE = 0 # Don't care or don't know
|
|
FF_ROMAN = 1 # with serifs, proportional
|
|
FF_SWISS = 2 # w/out serifs, proportional
|
|
FF_MODERN = 3 # constant stroke width
|
|
FF_SCRIPT = 4 # handwritten
|
|
FF_DECORATIVE = 5 # novelty
|
|
|
|
|
|
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 NEWTEXTMETRICW(ctypes.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', wintypes.WCHAR),
|
|
('mLastChar', wintypes.WCHAR),
|
|
('mDefaultChar', wintypes.WCHAR),
|
|
('mBreakChar', wintypes.WCHAR),
|
|
('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)]
|
|
|
|
class NEWTEXTMETRICEXW(ctypes.Structure):
|
|
_fields_ = [
|
|
('ntmTm', NEWTEXTMETRICW),
|
|
('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
|
|
)
|
|
|
|
FONTENUMPROCW = ctypes.WINFUNCTYPE(
|
|
ctypes.c_int, # return non-0 to continue enumeration, 0 to stop
|
|
ctypes.POINTER(LOGFONTW),
|
|
ctypes.POINTER(NEWTEXTMETRICEXW),
|
|
wintypes.DWORD,
|
|
wintypes.LPARAM
|
|
)
|
|
|
|
|
|
# When running 64 bit windows, some types are not 32 bit, so Python/ctypes guesses wrong
|
|
gdi32.EnumFontFamiliesExA.argtypes = [
|
|
wintypes.HDC,
|
|
ctypes.POINTER(LOGFONT),
|
|
FONTENUMPROC,
|
|
wintypes.LPARAM,
|
|
wintypes.DWORD]
|
|
|
|
|
|
gdi32.EnumFontFamiliesExW.argtypes = [
|
|
wintypes.HDC,
|
|
ctypes.POINTER(LOGFONTW),
|
|
FONTENUMPROCW,
|
|
wintypes.LPARAM,
|
|
wintypes.DWORD]
|
|
|
|
def _enum_font_names(logfont, textmetricex, fonttype, param):
|
|
"""callback function to be executed during EnumFontFamiliesEx
|
|
call for each font name. it stores names in global variable
|
|
"""
|
|
global FONTDB
|
|
|
|
lf = logfont.contents
|
|
name = lf.lfFaceName
|
|
|
|
# detect font type (vector|raster) and format (ttf)
|
|
# [ ] use Windows constant TRUETYPE_FONTTYPE
|
|
if fonttype & 4:
|
|
vector = True
|
|
fmt = 'ttf'
|
|
else:
|
|
vector = False
|
|
# [ ] research Windows raster format structure
|
|
fmt = 'unknown'
|
|
|
|
pitch = lf.lfPitchAndFamily & 0b11
|
|
family = lf.lfPitchAndFamily >> 4
|
|
|
|
# [ ] check FIXED_PITCH, VARIABLE_PITCH and FF_MODERN
|
|
# combination
|
|
#
|
|
# FP T NM 400 CHARSET: 0 DFKai-SB
|
|
# FP T NM 400 CHARSET: 136 DFKai-SB
|
|
# FP T NM 400 CHARSET: 0 @DFKai-SB
|
|
# FP T NM 400 CHARSET: 136 @DFKai-SB
|
|
# VP T M 400 CHARSET: 0 OCR A Extended
|
|
|
|
monospace = (pitch == FIXED_PITCH)
|
|
|
|
charset = lf.lfCharSet
|
|
|
|
FONTDB.append(FontEntry(name, vector, fmt, monospace, family))
|
|
|
|
if DEBUG:
|
|
info = ''
|
|
|
|
if pitch == FIXED_PITCH:
|
|
info += 'FP '
|
|
elif pitch == VARIABLE_PITCH:
|
|
info += 'VP '
|
|
else:
|
|
info += ' '
|
|
|
|
# [ ] check exact fonttype values meaning
|
|
info += '%s ' % {0: 'U', 1: 'R', 4: 'T'}[fonttype]
|
|
|
|
if monospace:
|
|
info += 'M '
|
|
else:
|
|
info += 'NM '
|
|
|
|
style = [' '] * 3
|
|
if lf.lfItalic:
|
|
style[0] = 'I'
|
|
if lf.lfUnderline:
|
|
style[1] = 'U'
|
|
if lf.lfStrikeOut:
|
|
style[2] = 'S'
|
|
info += ''.join(style)
|
|
|
|
info += ' %s' % lf.lfWeight
|
|
|
|
# if pitch == FIXED_PITCH:
|
|
if 1:
|
|
# print('%s CHARSET: %3s %s' % (info, lf.lfCharSet, lf.lfFaceName))
|
|
print(f'{info} CHARSET: {lf.lfCharSet} {lf.lfFaceName}')
|
|
|
|
return 1 # non-0 to continue enumeration
|
|
|
|
|
|
enum_font_names = FONTENUMPROCW(_enum_font_names)
|
|
|
|
|
|
# --- /define
|
|
|
|
|
|
# --- prepare and call EnumFontFamiliesEx
|
|
|
|
def query(charset=DEFAULT_CHARSET):
|
|
"""
|
|
Prepare and call EnumFontFamiliesEx.
|
|
|
|
query()
|
|
- return tuple with sorted list of all available system fonts
|
|
query(charset=ANSI_CHARSET)
|
|
- return tuple sorted list of system fonts supporting ANSI charset
|
|
|
|
"""
|
|
global FONTDB
|
|
|
|
# 1. Get device context of the entire screen
|
|
with device_context(None) as hdc:
|
|
|
|
# 2. Call EnumFontFamiliesExA (ANSI version)
|
|
|
|
# 2a. Call with empty font name to query all available fonts
|
|
# (or fonts for the specified charset)
|
|
#
|
|
# NOTES:
|
|
#
|
|
# * there are fonts that don't support ANSI charset
|
|
# * for DEFAULT_CHARSET font is passed to callback function as
|
|
# many times as charsets it supports
|
|
|
|
# [ ] font name should be less than 32 symbols with terminating \0
|
|
# [ ] check double purpose - enumerate all available font names
|
|
# - enumerate all available charsets for a single font
|
|
# - other params?
|
|
|
|
logfont = LOGFONTW(0, 0, 0, 0, 0, 0, 0, 0, charset, 0, 0, 0, 0, '')
|
|
FONTDB = [] # clear cached FONTDB for enum_font_names callback
|
|
res = gdi32.EnumFontFamiliesExW(
|
|
hdc, # handle to device context
|
|
ctypes.byref(logfont),
|
|
enum_font_names, # pointer to callback function
|
|
0, # lParam - application-supplied data
|
|
0) # dwFlags - reserved = 0
|
|
# res here is the last value returned by callback function
|
|
|
|
return FONTDB
|
|
|
|
|
|
# --- Public API ---
|
|
|
|
def have_font(name, refresh=False):
|
|
"""
|
|
Return True if font with specified `name` is present. The result
|
|
of querying system font names is cached. Set `refresh` parameter
|
|
to True to purge cache and reload font information.
|
|
"""
|
|
if not FONTDB or refresh:
|
|
query()
|
|
if any(f.name == name for f in FONTDB):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
def font_list(vector_only=False, monospace_only=False):
|
|
"""Return list of system installed font names."""
|
|
|
|
if not FONTDB:
|
|
query()
|
|
|
|
fonts = FONTDB
|
|
if vector_only:
|
|
fonts = [f for f in fonts if f.vector]
|
|
if monospace_only:
|
|
fonts = [f for f in fonts if f.monospace]
|
|
|
|
return sorted([f.name for f in fonts])
|
|
|
|
|
|
# TODO: move this into tests/
|
|
if __name__ == '__main__':
|
|
import sys
|
|
|
|
if sys.argv[1:] == ['debug']:
|
|
DEBUG = True
|
|
|
|
if sys.argv[1:] == ['test'] or DEBUG:
|
|
print('Running tests..')
|
|
# test have_font (Windows)
|
|
test_arial = have_font('Arial')
|
|
print('Have font "Arial"? %s' % test_arial)
|
|
print('Have font "missing-one"? %s' % have_font('missing-one'))
|
|
# test cache is not rebuilt
|
|
FONTDB = [FontEntry('stub', False, '', False, FF_MODERN)]
|
|
assert (have_font('Arial') != test_arial)
|
|
# test cache is rebiult
|
|
assert (have_font('Arial', refresh=True) == test_arial)
|
|
if not DEBUG:
|
|
sys.exit()
|
|
|
|
if sys.argv[1:] == ['vector']:
|
|
fonts = font_list(vector_only=True)
|
|
elif sys.argv[1:] == ['mono']:
|
|
fonts = font_list(monospace_only=True)
|
|
elif sys.argv[1:] == ['vector', 'mono']:
|
|
fonts = font_list(vector_only=True, monospace_only=True)
|
|
else:
|
|
fonts = font_list()
|
|
print('\n'.join(fonts))
|
|
|
|
if DEBUG:
|
|
print(f"Total: {len(font_list())}")
|
|
|
|
|
|
# -- CHAPTER 2: WORK WITH FONT DIMENSIONS --
|
|
#
|
|
# Essential info about font metrics http://support.microsoft.com/kb/32667
|
|
# And about logical units at http://www.winprog.org/tutorial/fonts.html
|
|
|
|
# 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 ...
|
|
|
|
|
|
# -- CHAPTER 3: LAYERED FONT API --
|
|
#
|
|
# 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
|