257 lines
8.9 KiB
Python
257 lines
8.9 KiB
Python
"""Load fonts.
|
|
|
|
pyglet will automatically load any system-installed fonts. You can add additional fonts
|
|
(for example, from your program resources) using :meth:`add_file` or
|
|
:meth:`add_directory`. These fonts are then available in the same way as system-installed fonts::
|
|
|
|
from pyglet import font
|
|
font.add_file('action_man.ttf')
|
|
action_man = font.load('Action Man', 16)
|
|
# or
|
|
from pyglet import resource
|
|
resource.add_font('action_man.ttf')
|
|
action_man = font.load('Action Man')
|
|
|
|
See the :mod:`pyglet.font.base` module for documentation on the base classes used
|
|
by this package.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import weakref
|
|
from typing import Dict, Union, BinaryIO, Optional, List, Iterable
|
|
|
|
import pyglet
|
|
from pyglet.font.user import UserDefinedFont
|
|
from pyglet import gl
|
|
|
|
|
|
def _get_system_font_class():
|
|
"""Get the appropriate class for the system being used.
|
|
Pyglet relies on OS dependent font systems for loading fonts and glyph creation.
|
|
"""
|
|
if pyglet.compat_platform == 'darwin':
|
|
from pyglet.font.quartz import QuartzFont
|
|
_font_class = QuartzFont
|
|
|
|
elif pyglet.compat_platform in ('win32', 'cygwin'):
|
|
from pyglet.libs.win32.constants import WINDOWS_7_OR_GREATER
|
|
if WINDOWS_7_OR_GREATER and not pyglet.options['win32_gdi_font']:
|
|
from pyglet.font.directwrite import Win32DirectWriteFont
|
|
_font_class = Win32DirectWriteFont
|
|
else:
|
|
from pyglet.font.win32 import GDIPlusFont
|
|
_font_class = GDIPlusFont
|
|
else:
|
|
from pyglet.font.freetype import FreeTypeFont
|
|
_font_class = FreeTypeFont
|
|
|
|
return _font_class
|
|
|
|
|
|
def create_font(name: str, mappings: Dict[str, pyglet.image.ImageData], default_char: str,
|
|
ascent: Optional[float] = None,
|
|
descent: Optional[float] = None, size: Optional[float] = None, bold: bool = False,
|
|
italic: bool = False, stretch: bool = False, dpi: Optional[float] = None,
|
|
font_class=UserDefinedFont):
|
|
"""
|
|
Create a custom font with the mappings provided.
|
|
|
|
If a character in a string is not mapped in the font, it will use the default_char as fallback.
|
|
|
|
Default size is 12.
|
|
Ascent and descent will use the image dimensions as default, but can be provided.
|
|
|
|
The rest of the font parameters are used for font lookups.
|
|
"""
|
|
# Arbitrary default size
|
|
if size is None:
|
|
size = 12
|
|
|
|
if dpi is None:
|
|
dpi = 96
|
|
|
|
# Locate or create font cache
|
|
shared_object_space = gl.current_context.object_space
|
|
if not hasattr(shared_object_space, 'pyglet_font_font_cache'):
|
|
shared_object_space.pyglet_font_font_cache = weakref.WeakValueDictionary()
|
|
shared_object_space.pyglet_font_font_hold = []
|
|
shared_object_space.pyglet_font_font_name_match = {} # Match a tuple to specific name to reduce lookups.
|
|
|
|
font_cache = shared_object_space.pyglet_font_font_cache
|
|
font_hold = shared_object_space.pyglet_font_font_hold
|
|
|
|
# Look for font name in font cache
|
|
descriptor = (name, size, bold, italic, stretch, dpi)
|
|
if descriptor in font_cache:
|
|
raise Exception("A font with these parameters has already been created.", descriptor)
|
|
|
|
if _system_font_class.have_font(name):
|
|
raise Exception(f"Font name: '{name}' already exists within the system fonts.")
|
|
|
|
# Not in cache, create from scratch
|
|
font = font_class(mappings, default_char, name, ascent, descent, size, bold, italic, stretch, dpi)
|
|
|
|
# Save parameters for new-style layout classes to recover
|
|
# TODO: add properties to the Font classes, so these can be queried:
|
|
font.size = size
|
|
font.bold = bold
|
|
font.italic = italic
|
|
font.stretch = stretch
|
|
font.dpi = dpi
|
|
|
|
if name not in _user_fonts:
|
|
_user_fonts.append(name)
|
|
|
|
# Cache font in weak-ref dictionary to avoid reloading while still in use
|
|
font_cache[descriptor] = font
|
|
|
|
# Hold onto refs of last three loaded fonts to prevent them being
|
|
# collected if momentarily dropped.
|
|
del font_hold[3:]
|
|
font_hold.insert(0, font)
|
|
|
|
return font
|
|
|
|
|
|
def have_font(name: str) -> bool:
|
|
"""Check if specified system font name is available."""
|
|
return name in _user_fonts or _system_font_class.have_font(name)
|
|
|
|
|
|
def load(name: Optional[Union[str, Iterable[str]]] = None, size: Optional[float] = None, bold: bool = False,
|
|
italic: bool = False,
|
|
stretch: bool = False, dpi: Optional[float] = None):
|
|
"""Load a font for rendering.
|
|
|
|
:Parameters:
|
|
`name` : str, or list of str
|
|
Font family, for example, "Times New Roman". If a list of names
|
|
is provided, the first one matching a known font is used. If no
|
|
font can be matched to the name(s), a default font is used. In
|
|
pyglet 1.1, the name may be omitted.
|
|
`size` : float
|
|
Size of the font, in points. The returned font may be an exact
|
|
match or the closest available.
|
|
`bold` : bool
|
|
If True, a bold variant is returned, if one exists for the given
|
|
family and size.
|
|
`italic` : bool
|
|
If True, an italic variant is returned, if one exists for the given
|
|
family and size.
|
|
`dpi` : float
|
|
The assumed resolution of the display device, for the purposes of
|
|
determining the pixel size of the font. Defaults to 96.
|
|
|
|
:rtype: `Font`
|
|
"""
|
|
# Arbitrary default size
|
|
if size is None:
|
|
size = 12
|
|
|
|
if dpi is None:
|
|
dpi = 96
|
|
|
|
# Locate or create font cache
|
|
shared_object_space = gl.current_context.object_space
|
|
if not hasattr(shared_object_space, 'pyglet_font_font_cache'):
|
|
shared_object_space.pyglet_font_font_cache = weakref.WeakValueDictionary()
|
|
shared_object_space.pyglet_font_font_hold = []
|
|
shared_object_space.pyglet_font_font_name_match = {} # Match a tuple to specific name to reduce lookups.
|
|
|
|
font_cache = shared_object_space.pyglet_font_font_cache
|
|
font_hold = shared_object_space.pyglet_font_font_hold
|
|
font_name_match = shared_object_space.pyglet_font_font_name_match
|
|
|
|
name_type = type(name)
|
|
if name_type in (tuple, list):
|
|
if name_type == list:
|
|
name = tuple(name)
|
|
|
|
if name in font_name_match:
|
|
name = font_name_match[name]
|
|
else:
|
|
# Find first matching name, cache it.
|
|
found_name = None
|
|
for n in name:
|
|
if n in _user_fonts or _system_font_class.have_font(n):
|
|
found_name = n
|
|
break
|
|
|
|
font_name_match[name] = found_name
|
|
name = found_name
|
|
|
|
# Look for font name in font cache
|
|
descriptor = (name, size, bold, italic, stretch, dpi)
|
|
if descriptor in font_cache:
|
|
return font_cache[descriptor]
|
|
|
|
# Not in cache, create from scratch
|
|
font = _system_font_class(name, size, bold=bold, italic=italic, stretch=stretch, dpi=dpi)
|
|
|
|
# Save parameters for new-style layout classes to recover
|
|
# TODO: add properties to the Font classes, so these can be queried:
|
|
font.size = size
|
|
font.bold = bold
|
|
font.italic = italic
|
|
font.stretch = stretch
|
|
font.dpi = dpi
|
|
|
|
# Cache font in weak-ref dictionary to avoid reloading while still in use
|
|
font_cache[descriptor] = font
|
|
|
|
# Hold onto refs of last three loaded fonts to prevent them being
|
|
# collected if momentarily dropped.
|
|
del font_hold[3:]
|
|
font_hold.insert(0, font)
|
|
|
|
return font
|
|
|
|
|
|
if not getattr(sys, 'is_pyglet_doc_run', False):
|
|
_system_font_class = _get_system_font_class()
|
|
_user_fonts = []
|
|
|
|
|
|
def add_file(font: Union[str, BinaryIO]):
|
|
"""Add a font to pyglet's search path.
|
|
|
|
In order to load a font that is not installed on the system, you must
|
|
call this method to tell pyglet that it exists. You can supply
|
|
either a filename or any file-like object.
|
|
|
|
The font format is platform-dependent, but is typically a TrueType font
|
|
file containing a single font face. Note that to use a font added with this method,
|
|
you should pass the face name (not the file name) to :meth::py:func:`pyglet.font.load` or any
|
|
other place where you normally specify a font.
|
|
|
|
:Parameters:
|
|
`font` : str or file-like object
|
|
Filename or file-like object to load fonts from.
|
|
|
|
"""
|
|
if isinstance(font, str):
|
|
font = open(font, 'rb')
|
|
if hasattr(font, 'read'):
|
|
font = font.read()
|
|
_system_font_class.add_font_data(font)
|
|
|
|
|
|
def add_directory(directory):
|
|
"""Add a directory of fonts to pyglet's search path.
|
|
|
|
This function simply calls :meth:`pyglet.font.add_file` for each file with a ``.ttf``
|
|
extension in the given directory. Subdirectories are not searched.
|
|
|
|
:Parameters:
|
|
`dir` : str
|
|
Directory that contains font files.
|
|
|
|
"""
|
|
for file in os.listdir(directory):
|
|
if file[-4:].lower() == '.ttf':
|
|
add_file(os.path.join(directory, file))
|
|
|
|
|
|
__all__ = ('add_file', 'add_directory', 'load', 'have_font')
|