')?&G O
˖-j]s |e A @./{vUkkfa[[*ΜfEѩ2=VVG,w[JVU[[
IŜ(Og TP TtIZٹL&澊=]9]5ɹ.}'5m9OһcD @ua
P%wtlLjkN&w~h֬stG.>fKn=f韗M O@*1sz-ڛg2wUy{f,Nx3k~'|H-&| ;PE\I;{ E5[nej&kNH`g|lÆ ٹ34 @,
e-fя$Mφt[oE&?/i}iϜ/N;VԻ
Ɔٙ2v @U" U*k9~&>"HBGG655z+\tmWm[̺C;|s!DwJs54/,_ T%oNt $-8q---n?{Oޫ N[JniJݤ I&} P @K/sO!Nd2jomm9k@NQ;xJxV_fl*6ܜ7.#3 g2wߞ;g͚Q6 ^---ӒI4m54ojw9Zys3*ey!5 oo32{5sOe֣ªBd:xYyZ `l" l6{pf뷔*x{ssbJcOϺa{N{TA&yU%; != 0@ +DR~pwwqΜ9V45S\_-Ud"ݪ{n93g> N{
}] p>Չ&I˿xS Iq% 瞸U[q]o:묦 vC PR6b]!i\?/.H?袥w % a, %R?kC?/5lHREW=-N
~bf?]B9 ʋ' d^En}êOH%In6 W.\[a&mmfVw;3J @,L.:wkz+Zd9n)%JL? ;k N^w- j^iяk @L y!_T_\#a]_r1BWfɗU}_7jkk => b dE^҄\%J5oj'=-QkMson9:ǒNOoy*JV: ںd)LeWttt]` %] -52 ]ӗKz .o 7]8_ds}Wқ{dV8W @y@ JssI&]p!hN:~| ^rBS~p6tCC? ?AknnNL4 .ޙNWƽ}qͺuLS?R((={v= d2*TFw/ΚunC[ZZ%ѻ$-t Z-Jm ` *]~Y.ɖ͢=Hђߙ E7KO=y @@ ].;=LܽC S^ { gH6B~v)z Ci0'C^ ] v rLfv&WIa[ 0
!NWHz{I
F e˖MR=owR A Pqlyfv]Wה? 0t E{⚵kL0qC Hw ZhQ4}HgK.X bX[IOHzXݣKROC ` F uuuSԦ @Ű
/ ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! aCbe IENDB` harfbuzz-uharfbuzz-7a648c4/pyproject.toml 0000664 0000000 0000000 00000003105 15266700675 0020656 0 ustar 00root root 0000000 0000000 [build-system]
requires = [
"setuptools >= 36.4",
"wheel",
"setuptools_scm >= 2.1",
"cython >= 3.1",
"pkgconfig"
]
build-backend = "setuptools.build_meta"
[tool.setuptools_scm]
[tool.cibuildwheel]
# Also skip wheels for free-threaded CPython 3.14 (e.g. 'cp314t') until we
# actually support them. We currently aren't thread-safe as we define HB_NO_MT=1.
# CPython abi3 wheels only need universal2 on macOS, skip the single-arch builds.
# Pyodide 3.15 wheel fails to import.
# Minimum supported CPython/PyPy is 3.11 (see setup.py).
skip = [
"cp38-*", "cp39-*", "cp310-*", "pp310-*",
"cp3??t-*", "cp*-macosx_x86_64", "cp*-macosx_arm64",
"cp315-pyodide_wasm32",
]
enable = ["pypy"]
test-requires = "pytest"
test-command = "pytest {project}/tests"
[tool.cibuildwheel.macos]
archs = ["x86_64", "universal2", "arm64"]
[tool.cibuildwheel.linux]
archs = ["native"]
# Run abi3audit after the default repair commands to scan for abi3 violations
# https://github.com/pypa/abi3audit
# Only on Unix platforms (Linux/macOS) since Windows has no default repair command
[[tool.cibuildwheel.overrides]]
select = "cp*-{linux,macosx}*"
inherit.repair-wheel-command = "append"
repair-wheel-command = "pipx run abi3audit --strict --report {wheel}"
# Disable Limited API for PyPy as the build currently fails, see:
# https://github.com/harfbuzz/uharfbuzz/issues/262#issuecomment-3415144557
# https://cibuildwheel.pypa.io/en/stable/configuration/#overrides
[[tool.cibuildwheel.overrides]]
select = "pp*"
environment = { USE_PY_LIMITED_API = "0" }
[tool.black]
extend-exclude = "harfbuzz"
harfbuzz-uharfbuzz-7a648c4/requirements-dev.txt 0000664 0000000 0000000 00000000151 15266700675 0022000 0 ustar 00root root 0000000 0000000 cython>=3.1
# we need wheel >= 0.31.0 to support Markdown long_description
wheel>=0.31
pytest
coverage
harfbuzz-uharfbuzz-7a648c4/setup.cfg 0000664 0000000 0000000 00000000042 15266700675 0017560 0 ustar 00root root 0000000 0000000 [metadata]
license_file = LICENSE
harfbuzz-uharfbuzz-7a648c4/setup.py 0000775 0000000 0000000 00000020201 15266700675 0017453 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import platform
import sys
from io import open
from typing import List
from Cython.Build import cythonize
from setuptools import Extension, setup
def is_emscripten_build() -> bool:
"""Detect if we're building for Emscripten/Pyodide."""
return sys.platform == "emscripten" or os.environ.get(
"_PYTHON_HOST_PLATFORM", ""
).startswith("emscripten")
def bool_from_environ(key: str, default: bool = False):
value = os.environ.get(key)
if not value:
return default
if value == "1":
return True
if value == "0":
return False
raise ValueError(
f"Environment variable {key} has invalid value {value}. Please set it to 1, 0 or an empty string"
)
here = os.path.abspath(os.path.dirname(__file__))
# Get the long description from the README file
with open(os.path.join(here, "README.md"), encoding="utf-8") as f:
long_description = f.read()
use_system_libraries = bool_from_environ("USE_SYSTEM_LIBS")
use_cython_linetrace = bool_from_environ("CYTHON_LINETRACE")
use_cython_annotate = bool_from_environ("CYTHON_ANNOTATE")
# Python Limited API for stable ABI support is enabled by default.
# Set USE_PY_LIMITED_API=0 to turn it off.
# https://docs.python.org/3.14/c-api/stable.html#limited-c-api
use_py_limited_api = bool_from_environ("USE_PY_LIMITED_API", default=True)
# NOTE: this must be kept in sync with python_requires='>=3.11' below
limited_api_min_version = "0x030B0000"
def _configure_extensions_with_system_libs() -> List[Extension]:
import pkgconfig
include_dirs = []
define_macros = []
libraries = []
library_dirs = []
harfbuzz_components = ["harfbuzz-subset", "harfbuzz-raster"]
for harfbuzz_component in harfbuzz_components:
harfbuzz_component_configuration = pkgconfig.parse(harfbuzz_component)
include_dirs += harfbuzz_component_configuration["include_dirs"]
define_macros += harfbuzz_component_configuration["define_macros"]
libraries += harfbuzz_component_configuration["libraries"]
library_dirs += harfbuzz_component_configuration["library_dirs"]
if use_cython_linetrace:
define_macros.append(("CYTHON_TRACE_NOGIL", "1"))
if use_py_limited_api:
define_macros.append(("Py_LIMITED_API", limited_api_min_version))
extension = Extension(
"uharfbuzz._harfbuzz",
define_macros=define_macros,
include_dirs=include_dirs,
sources=[
"src/uharfbuzz/_harfbuzz.pyx",
],
language="c++",
libraries=libraries,
library_dirs=library_dirs,
py_limited_api=use_py_limited_api,
)
extension_test = Extension(
"uharfbuzz._harfbuzz_test",
define_macros=define_macros,
include_dirs=include_dirs,
sources=[
"src/uharfbuzz/_draw_test_funcs.cc",
"src/uharfbuzz/_harfbuzz_test.pyx",
],
language="c++",
libraries=libraries,
library_dirs=library_dirs,
py_limited_api=use_py_limited_api,
)
return [extension, extension_test]
def _configure_extensions_with_vendored_libs() -> List[Extension]:
define_macros = [
("HB_NO_MT", "1"),
("HB_HAS_SUBSET", "1"),
("HB_HAS_RASTER", "1"),
]
extra_compile_args = []
extra_link_args = []
libraries = []
sources = ["harfbuzz/src/harfbuzz-world.cc", "src/uharfbuzz/_harfbuzz.pyx"]
emscripten = is_emscripten_build()
if use_cython_linetrace:
define_macros.append(("CYTHON_TRACE_NOGIL", "1"))
limited_api = use_py_limited_api
if limited_api:
define_macros.append(("Py_LIMITED_API", limited_api_min_version))
if platform.system() == "Windows" and not emscripten:
define_macros.append(("HB_HAS_DIRECTWRITE", "1"))
define_macros.append(("HB_HAS_UNISCRIBE", "1"))
libraries += ["usp10", "gdi32", "user32", "rpcrt4", "dwrite"]
else:
extra_compile_args.append("-std=c++11")
extra_compile_args.append("-g0")
define_macros.append(("HAVE_MMAP", "1"))
define_macros.append(("HAVE_UNISTD_H", "1"))
define_macros.append(("HAVE_SYS_MMAN_H", "1"))
if platform.system() == "Darwin" and not emscripten:
define_macros.append(("HB_HAS_CORETEXT", "1"))
extra_link_args.extend(["-framework", "ApplicationServices"])
extension = Extension(
"uharfbuzz._harfbuzz",
define_macros=define_macros,
include_dirs=["harfbuzz/src"],
sources=sources,
language="c++",
libraries=libraries,
extra_compile_args=extra_compile_args,
extra_link_args=extra_link_args,
py_limited_api=limited_api,
)
extension_test = Extension(
"uharfbuzz._harfbuzz_test",
define_macros=define_macros,
include_dirs=["harfbuzz/src"],
sources=[
"src/uharfbuzz/_draw_test_funcs.cc",
"src/uharfbuzz/_harfbuzz_test.pyx",
],
language="c++",
libraries=libraries,
extra_compile_args=extra_compile_args,
extra_link_args=extra_link_args,
py_limited_api=limited_api,
)
return [extension, extension_test]
def configure_extensions() -> List[Extension]:
if use_system_libraries:
return _configure_extensions_with_system_libs()
else:
return _configure_extensions_with_vendored_libs()
def _generate_field_docs() -> None:
import ast
import re
import textwrap
pkg_dir = os.path.join(here, "src", "uharfbuzz")
output_name = "_generated_docs.pxi"
output = os.path.join(pkg_dir, output_name)
# Locate `class Foo(... NamedTuple ...):` headers; the body is parsed as
# AST so it tolerates any consistent indentation.
class_re = re.compile(
r"^class\s+(\w+)[^:]*\bNamedTuple\b[^:]*:[^\n]*\n"
r"((?:[ \t]+.*\n|\s*\n)*)",
re.MULTILINE,
)
assignments: List[str] = []
for fname in sorted(os.listdir(pkg_dir)):
if not fname.endswith(".pxi") or fname == output_name:
continue
with open(os.path.join(pkg_dir, fname), encoding="utf-8") as f:
source = f.read()
for cls_match in class_re.finditer(source):
cls_name = cls_match.group(1)
body_nodes = ast.parse(textwrap.dedent(cls_match.group(2))).body
for i, node in enumerate(body_nodes):
if (
isinstance(node, ast.AnnAssign)
and isinstance(node.target, ast.Name)
and i + 1 < len(body_nodes)
and isinstance(body_nodes[i + 1], ast.Expr)
and isinstance(body_nodes[i + 1].value, ast.Constant)
and isinstance(body_nodes[i + 1].value.value, str)
):
doc = " ".join(body_nodes[i + 1].value.value.split())
assignments.append(
f"{cls_name}.{node.target.id}.__doc__ = {doc!r}"
)
content = "# Generated by setup.py; do not edit.\n" + "\n".join(assignments) + "\n"
# Only rewrite if changed, so Cython doesn't rebuild needlessly.
try:
with open(output, encoding="utf-8") as f:
if f.read() == content:
return
except FileNotFoundError:
pass
with open(output, "w", encoding="utf-8") as f:
f.write(content)
_generate_field_docs()
setup(
name="uharfbuzz",
use_scm_version={"write_to": "src/uharfbuzz/_version.py"},
description="Streamlined Cython bindings for the harfbuzz shaping engine",
long_description=long_description,
long_description_content_type="text/markdown",
author="Adrien Tétar",
author_email="adri-from-59@hotmail.fr",
url="https://github.com/trufont/uharfbuzz",
license="Apache License 2.0",
package_dir={"": "src"},
packages=["uharfbuzz"],
zip_safe=False,
setup_requires=["setuptools_scm"],
python_requires=">=3.11",
ext_modules=cythonize(
configure_extensions(),
annotate=use_cython_annotate,
compiler_directives={"linetrace": use_cython_linetrace},
),
options={"bdist_wheel": {"py_limited_api": "cp311"}} if use_py_limited_api else {},
)
harfbuzz-uharfbuzz-7a648c4/src/ 0000775 0000000 0000000 00000000000 15266700675 0016532 5 ustar 00root root 0000000 0000000 harfbuzz-uharfbuzz-7a648c4/src/uharfbuzz/ 0000775 0000000 0000000 00000000000 15266700675 0020552 5 ustar 00root root 0000000 0000000 harfbuzz-uharfbuzz-7a648c4/src/uharfbuzz/__init__.py 0000664 0000000 0000000 00000005132 15266700675 0022664 0 ustar 00root root 0000000 0000000 try:
from ._version import version as __version__
except ImportError:
__version__ = "0.0.0+unknown"
from ._harfbuzz import *
__all__ = [
"Blob",
"Buffer",
"BufferClusterLevel",
"BufferContentType",
"BufferFlags",
"BufferSerializeFlags",
"BufferSerializeFormat",
"Color",
"ColorLine",
"ColorStop",
"DrawFuncs",
"Face",
"Font",
"FontExtents",
"FontFuncs",
"GlyphExtents",
"GlyphFlags",
"GlyphInfo",
"GlyphPosition",
"HBObject",
"HarfBuzzError",
"Map",
"MapIter",
"OTColor",
"OTColorLayer",
"OTColorPalette",
"OTColorPaletteFlags",
"OTLayoutGlyphClass",
"OTMathConstant",
"OTMathGlyphPart",
"OTMathGlyphPartFlags",
"OTMathGlyphVariant",
"OTMathKern",
"OTMathKernEntry",
"OTMetricsTag",
"OTNameEntry",
"OTNameIdPredefined",
"OTVarAxisFlags",
"OTVarAxisInfo",
"OTVarNamedInstance",
"PaintCompositeMode",
"PaintExtend",
"PaintFuncs",
"RasterDraw",
"RasterExtents",
"RasterFormat",
"RasterImage",
"RasterPaint",
"RepackerError",
"SerializerError",
"Set",
"SetIter",
"StyleTag",
"SubsetFlags",
"SubsetInput",
"SubsetInputSets",
"SubsetPlan",
"__version__",
"ot_color_glyph_get_layers",
"ot_color_glyph_get_png",
"ot_color_glyph_get_svg",
"ot_color_glyph_has_paint",
"ot_color_has_layers",
"ot_color_has_paint",
"ot_color_has_palettes",
"ot_color_has_png",
"ot_color_has_svg",
"ot_color_palette_color_get_name_id",
"ot_color_palette_get_colors",
"ot_color_palette_get_count",
"ot_color_palette_get_flags",
"ot_color_palette_get_name_id",
"ot_font_set_funcs",
"ot_layout_get_baseline",
"ot_layout_get_glyph_class",
"ot_layout_has_glyph_classes",
"ot_layout_has_positioning",
"ot_layout_has_substitution",
"ot_layout_language_get_feature_tags",
"ot_layout_lookup_get_glyph_alternates",
"ot_layout_script_get_language_tags",
"ot_layout_table_get_script_tags",
"ot_math_get_constant",
"ot_math_get_glyph_assembly",
"ot_math_get_glyph_italics_correction",
"ot_math_get_glyph_kerning",
"ot_math_get_glyph_kernings",
"ot_math_get_glyph_top_accent_attachment",
"ot_math_get_glyph_variants",
"ot_math_get_min_connector_overlap",
"ot_math_has_data",
"ot_math_is_glyph_extended_shape",
"ot_tag_to_language",
"ot_tag_to_script",
"repack",
"repack_with_tag",
"serialize",
"serialize_with_tag",
"shape",
"subset",
"subset_preprocess",
"version_string",
]
harfbuzz-uharfbuzz-7a648c4/src/uharfbuzz/_blob.pxi 0000664 0000000 0000000 00000005245 15266700675 0022357 0 ustar 00root root 0000000 0000000 cdef class Blob:
"""Binary data containers.
Blobs wrap a chunk of binary data to handle lifecycle management of data
while it is passed between client and HarfBuzz. Blobs are primarily used
to create font faces, but also to access font face tables, as well as
pass around other binary data.
:param data: The binary data to wrap. If ``None`` or empty, the empty
blob is returned.
Wraps `hb_blob_t
`_.
"""
cdef hb_blob_t* _hb_blob
def __cinit__(self, bytes data = None):
if data is not None:
self._hb_blob = hb_blob_create(
data, len(data), HB_MEMORY_MODE_DUPLICATE, NULL, NULL)
else:
self._hb_blob = hb_blob_get_empty()
@staticmethod
cdef Blob from_ptr(hb_blob_t* hb_blob):
"""Create Blob from a pointer, taking ownership of it."""
cdef Blob wrapper = Blob.__new__(Blob)
wrapper._hb_blob = hb_blob
return wrapper
@classmethod
def from_file_path(cls, filename: Union[str, Path]) -> Blob:
"""Creates a new blob containing the data from the specified file.
The filename is passed directly to the system on all platforms, except
on Windows, where the filename is interpreted as UTF-8. Only if the
filename is not valid UTF-8, it will be interpreted according to the
system codepage.
:param filename: A filename.
:returns: A new :class:`Blob` with the content of the file.
:raises HarfBuzzError: If the file cannot be opened or read.
Wraps `hb_blob_create_from_file_or_fail()
`_.
"""
cdef bytes packed = os.fsencode(filename)
cdef hb_blob_t* blob = hb_blob_create_from_file_or_fail(packed)
if blob == NULL:
raise HarfBuzzError(f"Failed to open: {filename}")
cdef Blob inst = cls(None)
inst._hb_blob = blob
return inst
def __dealloc__(self):
hb_blob_destroy(self._hb_blob)
def __len__(self) -> int:
return hb_blob_get_length(self._hb_blob)
def __bool__(self) -> bool:
return len(self) > 0
@property
def data(self) -> bytes:
"""Fetches the data from a blob.
:type: bytes
Wraps `hb_blob_get_data()
`_.
"""
if not self:
return b""
cdef unsigned int blob_length
cdef const_char* blob_data = hb_blob_get_data(self._hb_blob, &blob_length)
return blob_data[:blob_length]
harfbuzz-uharfbuzz-7a648c4/src/uharfbuzz/_buffer.pxi 0000664 0000000 0000000 00000111635 15266700675 0022713 0 ustar 00root root 0000000 0000000 class GlyphFlags(IntFlag):
"""Flags for :class:`GlyphInfo`.
.. attribute:: UNSAFE_TO_BREAK
:value: 0x01
Indicates that if input text is broken at the beginning of the cluster
this glyph is part of, then both sides need to be re-shaped, as the
result might be different. On the flip side, it means that when this
flag is not present, then it is safe to break the glyph-run at the
beginning of this cluster, and the two sides will represent the exact
same result one would get if breaking input text at the beginning of
this cluster and shaping the two sides separately. This can be used
to optimize paragraph layout, by avoiding re-shaping of each line
after line-breaking.
.. attribute:: UNSAFE_TO_CONCAT
:value: 0x02
Indicates that if input text is changed on one side of the beginning
of the cluster this glyph is part of, then the shaping results for
the other side might change. Note that the absence of this flag
will NOT by itself mean that it IS safe to concat text. Only two
pieces of text both of which clear of this flag can be concatenated
safely. This can be used to optimize paragraph layout, by avoiding
re-shaping of each line after line-breaking, by limiting the
reshaping to a small piece around the breaking position only, even
if the breaking position carries the :attr:`UNSAFE_TO_BREAK` or
when hyphenation or other text transformation happens at line-break
position, in the following way:
1. Iterate back from the line-break position until the first
cluster start position that is NOT unsafe-to-concat,
2. shape the segment from there till the end of line,
3. check whether the resulting glyph-run also is clear of the
unsafe-to-concat at its start-of-text position; if it is, just
splice it into place and the line is shaped; If not, move on to a
position further back that is clear of unsafe-to-concat and retry
from there, and repeat.
At the start of next line a similar algorithm can be implemented.
That is:
1. Iterate forward from the line-break position until the first
cluster start position that is NOT unsafe-to-concat,
2. shape the segment from beginning of the line to that position,
3. check whether the resulting glyph-run also is clear of the
unsafe-to-concat at its end-of-text position; if it is, just splice
it into place and the beginning is shaped; If not, move on to a
position further forward that is clear of unsafe-to-concat and
retry up to there, and repeat.
A slight complication will arise in the implementation of the
algorithm above, because while our buffer API has a way to return
flags for position corresponding to start-of-text, there is
currently no position corresponding to end-of-text. This limitation
can be alleviated by shaping more text than needed and looking for
unsafe-to-concat flag within text clusters.
The :attr:`UNSAFE_TO_BREAK` flag will always imply this flag. To
use this flag, you must enable the buffer flag
:attr:`BufferFlags.PRODUCE_UNSAFE_TO_CONCAT` during shaping,
otherwise the buffer flag will not be reliably produced.
.. attribute:: SAFE_TO_INSERT_TATWEEL
:value: 0x04
In scripts that use elongation (Arabic, Mongolian, Syriac, etc.),
this flag signifies that it is safe to insert a U+0640 TATWEEL
character before this cluster for elongation. This flag does not
determine the script-specific elongation places, but only when it is
safe to do the elongation without interrupting text shaping.
Wraps `hb_glyph_flags_t
`_.
"""
UNSAFE_TO_BREAK = HB_GLYPH_FLAG_UNSAFE_TO_BREAK
UNSAFE_TO_CONCAT = HB_GLYPH_FLAG_UNSAFE_TO_CONCAT
SAFE_TO_INSERT_TATWEEL = HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL
cdef class GlyphInfo:
"""The structure that holds information about the glyphs and their
relation to input text.
Wraps `hb_glyph_info_t
`_.
"""
cdef hb_glyph_info_t _hb_glyph_info
# could maybe store Buffer to prevent GC
cdef set(self, hb_glyph_info_t info):
self._hb_glyph_info = info
@property
def codepoint(self) -> int:
"""Either a Unicode code point (before shaping) or a glyph index
(after shaping).
"""
return self._hb_glyph_info.codepoint
@property
def cluster(self) -> int:
"""The index of the character in the original text that corresponds
to this :class:`GlyphInfo`, or whatever the client passes to
:meth:`Buffer.add_codepoints`. More than one :class:`GlyphInfo` can
have the same ``cluster`` value, if they resulted from the same
character (e.g. one to many glyph substitution), and when more than
one character gets merged in the same glyph (e.g. many to one glyph
substitution) the :class:`GlyphInfo` will have the smallest cluster
value of them. By default some characters are merged into the same
cluster (e.g. combining marks have the same cluster as their bases)
even if they are separate glyphs, :attr:`Buffer.cluster_level` allows
selecting more fine-grained cluster handling.
"""
return self._hb_glyph_info.cluster
@property
def flags(self) -> GlyphFlags:
"""Glyph flags encoded within a :class:`GlyphInfo`.
:type: GlyphFlags
Wraps `hb_glyph_info_get_glyph_flags()
`_.
"""
return GlyphFlags(self._hb_glyph_info.mask & HB_GLYPH_FLAG_DEFINED)
cdef class GlyphPosition:
"""The structure that holds the positions of the glyph in both horizontal
and vertical directions. All positions in :class:`GlyphPosition` are
relative to the current point.
Wraps `hb_glyph_position_t
`_.
"""
cdef hb_glyph_position_t _hb_glyph_position
# could maybe store Buffer to prevent GC
cdef set(self, hb_glyph_position_t position):
self._hb_glyph_position = position
@property
def position(self) -> Tuple[int, int, int, int]:
"""A tuple of (:attr:`x_offset`, :attr:`y_offset`, :attr:`x_advance`,
:attr:`y_advance`).
"""
return (
self._hb_glyph_position.x_offset,
self._hb_glyph_position.y_offset,
self._hb_glyph_position.x_advance,
self._hb_glyph_position.y_advance
)
@property
def x_advance(self) -> int:
"""How much the line advances after drawing this glyph when setting
text in horizontal direction.
"""
return self._hb_glyph_position.x_advance
@property
def y_advance(self) -> int:
"""How much the line advances after drawing this glyph when setting
text in vertical direction.
"""
return self._hb_glyph_position.y_advance
@property
def x_offset(self) -> int:
"""How much the glyph moves on the X-axis before drawing it, this
should not affect how much the line advances.
"""
return self._hb_glyph_position.x_offset
@property
def y_offset(self) -> int:
"""How much the glyph moves on the Y-axis before drawing it, this
should not affect how much the line advances.
"""
return self._hb_glyph_position.y_offset
class BufferFlags(IntFlag):
"""Flags for :class:`Buffer`.
.. attribute:: DEFAULT
:value: 0x00
The default buffer flag.
.. attribute:: BOT
:value: 0x01
Flag indicating that special handling of the beginning of text
paragraph can be applied to this buffer. Should usually be set,
unless you are passing to the buffer only part of the text without
the full context.
.. attribute:: EOT
:value: 0x02
Flag indicating that special handling of the end of text paragraph
can be applied to this buffer, similar to :attr:`BOT`.
.. attribute:: PRESERVE_DEFAULT_IGNORABLES
:value: 0x04
Flag indication that character with Default_Ignorable Unicode
property should use the corresponding glyph from the font, instead of
hiding them (done by replacing them with the space glyph and zeroing
the advance width.) This flag takes precedence over
:attr:`REMOVE_DEFAULT_IGNORABLES`.
.. attribute:: REMOVE_DEFAULT_IGNORABLES
:value: 0x08
Flag indication that character with Default_Ignorable Unicode
property should be removed from glyph string instead of hiding them
(done by replacing them with the space glyph and zeroing the advance
width.) :attr:`PRESERVE_DEFAULT_IGNORABLES` takes precedence over
this flag.
.. attribute:: DO_NOT_INSERT_DOTTED_CIRCLE
:value: 0x10
Flag indicating that a dotted circle should not be inserted in the
rendering of incorrect character sequences (such at <0905 093E>).
.. attribute:: VERIFY
:value: 0x20
Flag indicating that the :func:`shape` call and its variants should
perform various verification processes on the results of the shaping
operation on the buffer. If the verification fails, then either a
buffer message is sent, if a message handler is installed on the
buffer, or a message is written to standard error. In either case,
the shaping result might be modified to show the failed output.
.. attribute:: PRODUCE_UNSAFE_TO_CONCAT
:value: 0x40
Flag indicating that the :attr:`GlyphFlags.UNSAFE_TO_CONCAT`
glyph-flag should be produced by the shaper. By default it will not
be produced since it incurs a cost.
.. attribute:: PRODUCE_SAFE_TO_INSERT_TATWEEL
:value: 0x80
Flag indicating that the :attr:`GlyphFlags.SAFE_TO_INSERT_TATWEEL`
glyph-flag should be produced by the shaper. By default it will not
be produced.
Wraps `hb_buffer_flags_t
`_.
"""
DEFAULT = HB_BUFFER_FLAG_DEFAULT
BOT = HB_BUFFER_FLAG_BOT
EOT = HB_BUFFER_FLAG_EOT
PRESERVE_DEFAULT_IGNORABLES = HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES
REMOVE_DEFAULT_IGNORABLES = HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES
DO_NOT_INSERT_DOTTED_CIRCLE = HB_BUFFER_FLAG_DO_NOT_INSERT_DOTTED_CIRCLE
VERIFY = HB_BUFFER_FLAG_VERIFY
PRODUCE_UNSAFE_TO_CONCAT = HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT
PRODUCE_SAFE_TO_INSERT_TATWEEL = HB_BUFFER_FLAG_PRODUCE_SAFE_TO_INSERT_TATWEEL
class BufferClusterLevel(IntEnum):
"""Data type for holding HarfBuzz's clustering behavior options. The
cluster level dictates one aspect of how HarfBuzz will treat non-base
characters during shaping.
:attr:`MONOTONE_GRAPHEMES` is the default, because it maintains backward
compatibility with older versions of HarfBuzz. New client programs that
do not need to maintain such backward compatibility are recommended to
use :attr:`MONOTONE_CHARACTERS` instead of the default.
.. attribute:: MONOTONE_GRAPHEMES
:value: 0
Return cluster values grouped by graphemes into monotone order.
Non-base characters are merged into the cluster of the base character
that precedes them. There is also cluster merging every time the
clusters will otherwise become non-monotone.
.. attribute:: MONOTONE_CHARACTERS
:value: 1
Return cluster values grouped into monotone order. Non-base
characters are initially assigned their own cluster values, which are
not merged into preceding base clusters. This allows HarfBuzz to
perform additional operations like reorder sequences of adjacent
marks. The output is still monotone, but the cluster values are more
granular.
.. attribute:: CHARACTERS
:value: 2
Don't group cluster values. Non-base characters are assigned their
own cluster values, which are not merged into preceding base
clusters. Moreover, the cluster values are not merged into monotone
order. This is the most granular cluster level, and it is useful for
clients that need to know the exact cluster values of each character,
but is harder to use for clients, since clusters might appear in any
order.
.. attribute:: GRAPHEMES
:value: 3
Only group clusters, but don't enforce monotone order. Non-base
characters are merged into the cluster of the base character that
precedes them. This is similar to the Unicode Grapheme Cluster
algorithm, but it is not exactly the same. The output is not forced
to be monotone. This is useful for clients that want to use HarfBuzz
as a cheap implementation of the Unicode Grapheme Cluster algorithm.
.. attribute:: DEFAULT
:value: MONOTONE_GRAPHEMES
Default cluster level, equal to :attr:`MONOTONE_GRAPHEMES`.
Wraps `hb_buffer_cluster_level_t
`_.
"""
MONOTONE_GRAPHEMES = HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES
MONOTONE_CHARACTERS = HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS
CHARACTERS = HB_BUFFER_CLUSTER_LEVEL_CHARACTERS
GRAPHEMES = HB_BUFFER_CLUSTER_LEVEL_GRAPHEMES
DEFAULT = HB_BUFFER_CLUSTER_LEVEL_DEFAULT
class BufferContentType(IntEnum):
"""The type of :class:`Buffer` contents.
.. attribute:: INVALID
:value: 0
Initial value for new buffer.
.. attribute:: UNICODE
:value: 1
The buffer contains input characters (before shaping).
.. attribute:: GLYPHS
:value: 2
The buffer contains output glyphs (after shaping).
Wraps `hb_buffer_content_type_t
`_.
"""
INVALID = HB_BUFFER_CONTENT_TYPE_INVALID
UNICODE = HB_BUFFER_CONTENT_TYPE_UNICODE
GLYPHS = HB_BUFFER_CONTENT_TYPE_GLYPHS
class BufferSerializeFormat(IntEnum):
"""The buffer serialization and de-serialization format used in
:meth:`Buffer.serialize`.
.. attribute:: TEXT
A human-readable, plain text format.
.. attribute:: JSON
A machine-readable JSON format.
.. attribute:: INVALID
Invalid format.
Wraps `hb_buffer_serialize_format_t
`_.
"""
TEXT = HB_BUFFER_SERIALIZE_FORMAT_TEXT
JSON = HB_BUFFER_SERIALIZE_FORMAT_JSON
INVALID = HB_BUFFER_SERIALIZE_FORMAT_INVALID
class BufferSerializeFlags(IntFlag):
"""Flags that control what glyph information are serialized in
:meth:`Buffer.serialize`.
.. attribute:: DEFAULT
:value: 0x00
Serialize glyph names, clusters and positions.
.. attribute:: NO_CLUSTERS
:value: 0x01
Do not serialize glyph cluster.
.. attribute:: NO_POSITIONS
:value: 0x02
Do not serialize glyph position information.
.. attribute:: NO_GLYPH_NAMES
:value: 0x04
Do not serialize glyph name.
.. attribute:: GLYPH_EXTENTS
:value: 0x08
Serialize glyph extents.
.. attribute:: GLYPH_FLAGS
:value: 0x10
Serialize glyph flags.
.. attribute:: NO_ADVANCES
:value: 0x20
Do not serialize glyph advances, glyph offsets will reflect absolute
glyph positions.
Note: when this flag is used with a partial range of the buffer
(i.e. ``start`` is not 0), calculating the absolute positions has a
cost proportional to ``start``. If the buffer is serialized in many
small chunks, this can lead to quadratic behavior. It is recommended
to use a larger ``buf_size`` to minimize this cost.
Wraps `hb_buffer_serialize_flags_t
`_.
"""
DEFAULT = HB_BUFFER_SERIALIZE_FLAG_DEFAULT
NO_CLUSTERS = HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS
NO_POSITIONS = HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS
NO_GLYPH_NAMES = HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES
GLYPH_EXTENTS = HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS
GLYPH_FLAGS = HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS
NO_ADVANCES = HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES
DEFINED = HB_BUFFER_SERIALIZE_FLAG_DEFINED
cdef class Buffer:
"""Input and output buffers.
Buffers serve a dual role in HarfBuzz; before shaping, they hold the
input characters that are passed to :func:`shape`, and after shaping they
hold the output glyphs.
The input buffer is a sequence of Unicode codepoints, with associated
attributes such as direction and script. The output buffer is a sequence
of glyphs, with associated attributes such as position and cluster.
.. attribute:: DEFAULT_REPLACEMENT_CODEPOINT
:value: 0xFFFD
The default code point for replacing invalid characters in a given
encoding. Set to U+FFFD REPLACEMENT CHARACTER.
Wraps `HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT
`_.
Wraps `hb_buffer_t
`_.
"""
cdef hb_buffer_t* _hb_buffer
cdef object _message_callback
DEFAULT_REPLACEMENT_CODEPOINT = HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT
def __cinit__(self):
self._hb_buffer = hb_buffer_create()
if not hb_buffer_allocation_successful(self._hb_buffer):
raise MemoryError()
self._message_callback = None
def __dealloc__(self):
hb_buffer_destroy(self._hb_buffer)
@classmethod
@deprecated("Buffer()", since="0.10.0")
def create(cls) -> Buffer:
cdef Buffer inst = cls()
return inst
def __len__(self) -> int:
return hb_buffer_get_length(self._hb_buffer)
def reset(self):
"""Resets the buffer to its initial status, as if it was just newly
created.
Wraps `hb_buffer_reset()
`_.
"""
hb_buffer_reset (self._hb_buffer)
def clear_contents(self):
"""Similar to :meth:`reset`, but does not clear the Unicode functions
and the replacement code point.
Wraps `hb_buffer_clear_contents()
`_.
"""
hb_buffer_clear_contents(self._hb_buffer)
@property
def direction(self) -> str:
"""The text flow direction of the buffer. No shaping can happen
without setting buffer direction, and it controls the visual
direction for the output glyphs; for RTL direction the glyphs will be
reversed. Many layout features depend on the proper setting of the
direction, for example, reversing RTL text before shaping, then
shaping with LTR direction is not the same as keeping the text in
logical order and shaping with RTL direction.
Wraps `hb_buffer_get_direction()
`_
/ `hb_buffer_set_direction()
`_.
"""
cdef const_char* cstr = hb_direction_to_string(
hb_buffer_get_direction(self._hb_buffer))
cdef bytes packed = cstr
return packed.decode()
@direction.setter
def direction(self, value: str):
cdef bytes packed = value.encode()
cdef char* cstr = packed
hb_buffer_set_direction(
self._hb_buffer, hb_direction_from_string(cstr, -1))
@property
def glyph_infos(self) -> List[GlyphInfo]:
"""The buffer glyph information array. The value is valid as long as
the buffer has not been modified.
:type: list[GlyphInfo]
Wraps `hb_buffer_get_glyph_infos()
`_.
"""
cdef unsigned int count
cdef hb_glyph_info_t* glyph_infos = hb_buffer_get_glyph_infos(
self._hb_buffer, &count)
cdef list infos = []
cdef GlyphInfo info
cdef unsigned int i
for i in range(count):
info = GlyphInfo()
info.set(glyph_infos[i])
infos.append(info)
return infos
@property
def glyph_positions(self) -> List[GlyphPosition]:
"""The buffer glyph position array. The value is valid as long as the
buffer has not been modified.
If the buffer did not have positions before, the positions will be
initialized to zeros, unless this property is accessed from within a
buffer message callback (see :meth:`set_message_func`), in which case
``None`` is returned.
:type: list[GlyphPosition] | None
Wraps `hb_buffer_get_glyph_positions()
`_.
"""
cdef unsigned int count
cdef hb_glyph_position_t* glyph_positions = \
hb_buffer_get_glyph_positions(self._hb_buffer, &count)
if glyph_positions is NULL:
return None
cdef list positions = []
cdef GlyphPosition position
cdef unsigned int i
for i in range(count):
position = GlyphPosition()
position.set(glyph_positions[i])
positions.append(position)
return positions
@property
def language(self) -> str:
"""The language of the buffer, as a BCP 47 language tag.
Languages are crucial for selecting which OpenType feature to apply
to the buffer which can result in applying language-specific
behaviour. Languages are orthogonal to the scripts, and though they
are related, they are different concepts and should not be confused
with each other.
Wraps `hb_buffer_get_language()
`_
/ `hb_buffer_set_language()
`_.
"""
cdef const_char* cstr = hb_language_to_string(
hb_buffer_get_language(self._hb_buffer))
if cstr is NULL:
return None
cdef bytes packed = cstr
return packed.decode()
@language.setter
def language(self, value: str):
cdef bytes packed = value.encode()
cdef char* cstr = packed
hb_buffer_set_language(
self._hb_buffer, hb_language_from_string(cstr, -1))
@property
def script(self) -> str:
"""The script of the buffer, as an ISO 15924 script tag.
Script is crucial for choosing the proper shaping behaviour for
scripts that require it (e.g. Arabic) and the which OpenType features
defined in the font to be applied.
Wraps `hb_buffer_get_script()
`_
/ `hb_buffer_set_script()
`_.
"""
cdef char cstr[5]
hb_tag_to_string(hb_buffer_get_script(self._hb_buffer), cstr)
cstr[4] = b'\0'
if cstr[0] == b'\0':
return None
cdef bytes packed = cstr
return packed.decode()
@script.setter
def script(self, value: str):
cdef bytes packed = value.encode()
cdef char* cstr = packed
# all the *_from_string calls should probably be checked and throw an
# exception if invalid
hb_buffer_set_script(
self._hb_buffer, hb_script_from_string(cstr, -1))
@property
def flags(self) -> BufferFlags:
"""The :class:`BufferFlags` of the buffer.
:type: BufferFlags
Wraps `hb_buffer_get_flags()
`_
/ `hb_buffer_set_flags()
`_.
"""
level = hb_buffer_get_flags(self._hb_buffer)
return BufferFlags(level)
@flags.setter
def flags(self, value: BufferFlags):
level = BufferFlags(value)
hb_buffer_set_flags(self._hb_buffer, level)
@property
def cluster_level(self) -> BufferClusterLevel:
"""The cluster level of the buffer. The :class:`BufferClusterLevel`
dictates one aspect of how HarfBuzz will treat non-base characters
during shaping.
:type: BufferClusterLevel
Wraps `hb_buffer_get_cluster_level()
`_
/ `hb_buffer_set_cluster_level()
`_.
"""
level = hb_buffer_get_cluster_level(self._hb_buffer)
return BufferClusterLevel(level)
@cluster_level.setter
def cluster_level(self, value: BufferClusterLevel):
level = BufferClusterLevel(value)
hb_buffer_set_cluster_level(self._hb_buffer, level)
@property
def content_type(self) -> BufferContentType:
"""The type of buffer contents. Buffers are either empty, contain
characters (before shaping), or contain glyphs (the result of
shaping).
:type: BufferContentType
Wraps `hb_buffer_get_content_type()
`_
/ `hb_buffer_set_content_type()
`_.
"""
level = hb_buffer_get_content_type(self._hb_buffer)
return BufferContentType(level)
@content_type.setter
def content_type(self, value: BufferContentType):
level = BufferContentType(value)
hb_buffer_set_content_type(self._hb_buffer, level)
@property
def replacement_codepoint(self) -> int:
"""The codepoint that replaces invalid entries for a given encoding
when adding text to the buffer.
Default is :attr:`DEFAULT_REPLACEMENT_CODEPOINT`.
Wraps `hb_buffer_get_replacement_codepoint()
`_
/ `hb_buffer_set_replacement_codepoint()
`_.
"""
return hb_buffer_get_replacement_codepoint(self._hb_buffer)
@replacement_codepoint.setter
def replacement_codepoint(self, value: int):
hb_buffer_set_replacement_codepoint(self._hb_buffer, value)
@property
def invisible_glyph(self) -> int:
"""The codepoint that replaces invisible characters in the shaping
result. If set to zero (default), the glyph for the U+0020 SPACE
character is used. Otherwise, this value is used verbatim.
Wraps `hb_buffer_get_invisible_glyph()
`_
/ `hb_buffer_set_invisible_glyph()
`_.
"""
return hb_buffer_get_invisible_glyph(self._hb_buffer)
@invisible_glyph.setter
def invisible_glyph(self, value: int):
hb_buffer_set_invisible_glyph(self._hb_buffer, value)
@property
def not_found_glyph(self) -> int:
"""The codepoint that replaces characters not found in the font
during shaping.
The not-found glyph defaults to zero, sometimes known as the
``.notdef`` glyph. This API allows for differentiating the two.
Wraps `hb_buffer_get_not_found_glyph()
`_
/ `hb_buffer_set_not_found_glyph()
`_.
"""
return hb_buffer_get_not_found_glyph(self._hb_buffer)
@not_found_glyph.setter
def not_found_glyph(self, value: int):
hb_buffer_set_not_found_glyph(self._hb_buffer, value)
def set_language_from_ot_tag(self, value: str):
"""Sets the language of the buffer from an OpenType language tag.
Wraps `hb_ot_tag_to_language()
`_
+ `hb_buffer_set_language()
`_.
"""
cdef bytes packed = value.encode()
cdef char* cstr = packed
hb_buffer_set_language(
self._hb_buffer, hb_ot_tag_to_language(hb_tag_from_string(cstr, -1)))
def set_script_from_ot_tag(self, value: str):
"""Sets the script of the buffer from an OpenType script tag.
Wraps `hb_ot_tag_to_script()
`_
+ `hb_buffer_set_script()
`_.
"""
cdef bytes packed = value.encode()
cdef char* cstr = packed
hb_buffer_set_script(
self._hb_buffer, hb_ot_tag_to_script(hb_tag_from_string(cstr, -1)))
def add_codepoints(self, codepoints: List[int],
item_offset: int = 0, item_length: int = -1):
"""Appends characters from ``codepoints`` to the buffer.
The ``item_offset`` is the position of the first character from
``codepoints`` that will be appended, and ``item_length`` is the
number of characters. When shaping part of a larger text (e.g. a run
of text from a paragraph), instead of passing just the substring
corresponding to the run, it is preferable to pass the whole
paragraph and specify the run start and length as ``item_offset`` and
``item_length``, respectively, to give HarfBuzz the full context to
be able, for example, to do cross-run Arabic shaping or properly
handle combining marks at start of run.
This method does not check the validity of ``codepoints``, it is up
to the caller to ensure it contains valid Unicode scalar values. In
contrast, :meth:`add_utf8` and :meth:`add_str` perform sanity-check
on the input.
:param codepoints: A sequence of Unicode code points to append.
:param item_offset: The offset of the first code point to add to the
buffer.
:param item_length: The number of code points to add to the buffer,
or ``-1`` to add the rest of ``codepoints``.
:raises MemoryError: If memory allocation fails.
Wraps `hb_buffer_add_codepoints()
`_.
"""
cdef unsigned int size = len(codepoints)
cdef hb_codepoint_t* hb_codepoints
if not size:
return
hb_codepoints = malloc(
size * sizeof(hb_codepoint_t))
for i in range(size):
hb_codepoints[i] = codepoints[i]
hb_buffer_add_codepoints(
self._hb_buffer, hb_codepoints, size, item_offset, item_length)
free(hb_codepoints)
if not hb_buffer_allocation_successful(self._hb_buffer):
raise MemoryError()
def add_utf8(self, text: bytes,
item_offset: int = 0, item_length: int = -1):
"""Appends UTF-8 ``text`` to the buffer.
Replaces invalid UTF-8 characters with the buffer replacement code
point, see :attr:`replacement_codepoint`.
:param text: UTF-8 encoded text to append.
:param item_offset: The offset of the first character to add to the
buffer.
:param item_length: The number of characters to add to the buffer,
or ``-1`` to add the rest of ``text``.
:raises MemoryError: If memory allocation fails.
Wraps `hb_buffer_add_utf8()
`_.
"""
hb_buffer_add_utf8(
self._hb_buffer, text, len(text), item_offset, item_length)
if not hb_buffer_allocation_successful(self._hb_buffer):
raise MemoryError()
def add_str(self, text: str,
item_offset: int = 0, item_length: int = -1):
"""Appends ``text`` to the buffer.
Replaces invalid characters with the buffer replacement code point,
see :attr:`replacement_codepoint`.
:param text: Text to append.
:param item_offset: The offset of the first character to add to the
buffer.
:param item_length: The number of characters to add to the buffer,
or ``-1`` to add the rest of ``text``.
:raises MemoryError: If memory allocation fails.
Wraps `hb_buffer_add_utf32()
`_.
"""
cdef Py_UCS4* ucs4_buffer
cdef Py_ssize_t text_length
ucs4_buffer = PyUnicode_AsUCS4Copy(text)
if ucs4_buffer == NULL:
raise MemoryError()
try:
text_length = PyUnicode_GetLength(text)
if text_length == -1:
raise ValueError("Invalid Unicode string")
hb_buffer_add_utf32(
self._hb_buffer,
ucs4_buffer,
text_length,
item_offset,
item_length
)
if not hb_buffer_allocation_successful(self._hb_buffer):
raise MemoryError()
finally:
PyMem_Free(ucs4_buffer)
def guess_segment_properties(self):
"""Sets unset buffer segment properties based on buffer Unicode
contents. If the buffer is not empty, it must have content type
:attr:`BufferContentType.UNICODE`.
If the buffer script is not set, it will be set to the Unicode script
of the first character in the buffer that has a script other than
``COMMON``, ``INHERITED``, and ``UNKNOWN``.
Next, if the buffer direction is not set, it will be set to the
natural horizontal direction of the buffer script.
Finally, if the buffer language is not set, it will be set to the
process's default language.
Wraps `hb_buffer_guess_segment_properties()
`_.
"""
hb_buffer_guess_segment_properties(self._hb_buffer)
def set_message_func(self, callback: Callable[str]):
"""Sets the implementation function for the buffer's message
callback.
The callback is called with a message describing what step of the
shaping process will be performed. Returning ``False`` from this
callback will skip this shaping step and move to the next one.
Wraps `hb_buffer_set_message_func()
`_.
"""
self._message_callback = callback
hb_buffer_set_message_func(self._hb_buffer, msgcallback, callback, NULL)
def serialize(self,
font: Font,
format: BufferSerializeFormat = BufferSerializeFormat.TEXT,
flags: BufferSerializeFlags = BufferSerializeFlags.DEFAULT) -> str:
"""Serializes the buffer into a textual representation of its
content, whether Unicode codepoints or glyph identifiers and
positioning information. This is useful for showing the contents of
the buffer, for example during debugging.
:param font: The :class:`Font` used to shape this buffer, needed to
read glyph names and extents.
:param format: The :class:`BufferSerializeFormat` to use for
formatting the output.
:param flags: The :class:`BufferSerializeFlags` that control what
glyph properties to serialize.
:returns: The serialized buffer contents.
Wraps `hb_buffer_serialize()
`_.
"""
cdef unsigned int num_glyphs = hb_buffer_get_length(self._hb_buffer)
cdef unsigned int start = 0
cdef char cstr[STATIC_ARRAY_SIZE]
cdef unsigned int consumed
cdef bytes packed = b""
while start < num_glyphs:
start += hb_buffer_serialize(
self._hb_buffer,
start,
num_glyphs,
cstr,
STATIC_ARRAY_SIZE,
&consumed,
font._hb_font,
format,
flags
)
if consumed == 0:
break
packed += cstr[:consumed]
return packed.decode()
harfbuzz-uharfbuzz-7a648c4/src/uharfbuzz/_draw.pxi 0000664 0000000 0000000 00000017174 15266700675 0022402 0 ustar 00root root 0000000 0000000 cdef void _move_to_func(hb_draw_funcs_t *dfuncs,
void *draw_data,
hb_draw_state_t *st,
float to_x,
float to_y,
void *user_data) noexcept:
m = user_data
m(to_x, to_y, draw_data)
cdef void _line_to_func(hb_draw_funcs_t *dfuncs,
void *draw_data,
hb_draw_state_t *st,
float to_x,
float to_y,
void *user_data) noexcept:
l = user_data
l(to_x, to_y, draw_data)
cdef void _close_path_func(hb_draw_funcs_t *dfuncs,
void *draw_data,
hb_draw_state_t *st,
void *user_data) noexcept:
cl = user_data
cl(draw_data)
cdef void _quadratic_to_func(hb_draw_funcs_t *dfuncs,
void *draw_data,
hb_draw_state_t *st,
float c1_x,
float c1_y,
float to_x,
float to_y,
void *user_data) noexcept:
q = user_data
q(c1_x, c1_y, to_x, to_y, draw_data)
cdef void _cubic_to_func(hb_draw_funcs_t *dfuncs,
void *draw_data,
hb_draw_state_t *st,
float c1_x,
float c1_y,
float c2_x,
float c2_y,
float to_x,
float to_y,
void *user_data) noexcept:
c = user_data
c(c1_x, c1_y, c2_x, c2_y, to_x, to_y, draw_data)
cdef class DrawFuncs:
cdef hb_draw_funcs_t* _hb_drawfuncs
cdef object _move_to_func
cdef object _line_to_func
cdef object _cubic_to_func
cdef object _quadratic_to_func
cdef object _close_path_func
def __cinit__(self):
self._hb_drawfuncs = hb_draw_funcs_create()
def __dealloc__(self):
hb_draw_funcs_destroy(self._hb_drawfuncs)
@deprecated("Font.draw_glyph()", since="0.34.0")
def get_glyph_shape(self, font: Font, gid: int):
font.draw_glyph(gid, self)
@deprecated("Font.draw_glyph()", since="0.34.0")
def draw_glyph(self, font: Font, gid: int, draw_data: object = None):
font.draw_glyph(gid, self, draw_data)
def set_move_to_func(self,
func: Callable[[
float,
float,
object, # draw_data
], None],
user_data: object = None):
cdef hb_draw_move_to_func_t func_p
cdef void *user_data_p
if PyCapsule_IsValid(func, NULL):
self._move_to_func = None
func_p = PyCapsule_GetPointer(func, NULL)
if PyCapsule_IsValid(user_data, NULL):
user_data_p = PyCapsule_GetPointer(user_data, NULL)
else:
user_data_p = user_data
else:
self._move_to_func = func
func_p = _move_to_func
assert user_data is None, "Pass draw_state to Font.draw_glyph"
user_data_p = func
hb_draw_funcs_set_move_to_func(
self._hb_drawfuncs, func_p, user_data_p, NULL)
def set_line_to_func(self,
func: Callable[[
float,
float,
object, # draw_data
], None],
user_data: object = None):
cdef hb_draw_line_to_func_t func_p
cdef void *user_data_p
if PyCapsule_IsValid(func, NULL):
self._line_to_func = None
func_p = PyCapsule_GetPointer(func, NULL)
if PyCapsule_IsValid(user_data, NULL):
user_data_p = PyCapsule_GetPointer(user_data, NULL)
else:
user_data_p = user_data
else:
self._line_to_func = func
func_p = _line_to_func
assert user_data is None, "Pass draw_state to Font.draw_glyph"
user_data_p = func
hb_draw_funcs_set_line_to_func(
self._hb_drawfuncs, func_p, user_data_p, NULL)
def set_cubic_to_func(self,
func: Callable[[
float,
float,
float,
float,
float,
float,
object, # draw_data
], None],
user_data: object = None):
cdef hb_draw_cubic_to_func_t func_p
cdef void *user_data_p
if PyCapsule_IsValid(func, NULL):
self._cubic_to_func = None
func_p = PyCapsule_GetPointer(func, NULL)
if PyCapsule_IsValid(user_data, NULL):
user_data_p = PyCapsule_GetPointer(user_data, NULL)
else:
user_data_p = user_data
else:
self._cubic_to_func = func
func_p = _cubic_to_func
assert user_data is None, "Pass draw_state to Font.draw_glyph"
user_data_p = func
hb_draw_funcs_set_cubic_to_func(
self._hb_drawfuncs, func_p, user_data_p, NULL)
def set_quadratic_to_func(self,
func: Callable[[
float,
float,
float,
float,
object, # draw_data
], None],
user_data: object = None):
cdef hb_draw_quadratic_to_func_t func_p
cdef void *user_data_p
if PyCapsule_IsValid(func, NULL):
self._quadratic_to_func = None
func_p = PyCapsule_GetPointer(func, NULL)
if PyCapsule_IsValid(user_data, NULL):
user_data_p = PyCapsule_GetPointer(user_data, NULL)
else:
user_data_p = user_data
else:
self._quadratic_to_func = func
func_p = _quadratic_to_func
assert user_data is None, "Pass draw_state to Font.draw_glyph"
user_data_p = func
hb_draw_funcs_set_quadratic_to_func(
self._hb_drawfuncs, func_p, user_data_p, NULL)
def set_close_path_func(self,
func: Callable[[
object
], None],
user_data: object = None):
cdef hb_draw_close_path_func_t func_p
cdef void *user_data_p
if PyCapsule_IsValid(func, NULL):
self._close_path_func = None
func_p = PyCapsule_GetPointer(func, NULL)
if PyCapsule_IsValid(user_data, NULL):
user_data_p = PyCapsule_GetPointer(user_data, NULL)
else:
user_data_p = user_data
else:
self._close_path_func = func
func_p = _close_path_func
assert user_data is None, "Pass draw_state to Font.draw_glyph"
user_data_p = func
hb_draw_funcs_set_close_path_func(
self._hb_drawfuncs, func_p, user_data_p, NULL)
harfbuzz-uharfbuzz-7a648c4/src/uharfbuzz/_draw_test_funcs.cc 0000664 0000000 0000000 00000003152 15266700675 0024413 0 ustar 00root root 0000000 0000000 #include
#include
#if defined (_MSC_VER)
#define EXTERN __declspec (dllexport) extern
#else
#define EXTERN extern
#endif
extern "C" {
EXTERN void
_test_move_to (void *dfuncs,
char *draw_data,
void *st,
float to_x,
float to_y,
void *user_data)
{
sprintf (draw_data + strlen (draw_data), "M%g,%g", to_x, to_y);
}
EXTERN void
_test_line_to (void *dfuncs,
char *draw_data,
void *st,
float to_x,
float to_y,
void *user_data)
{
sprintf (draw_data + strlen (draw_data), "L%g,%g", to_x, to_y);
}
EXTERN void
_test_close_path (void *dfuncs,
char *draw_data,
void *st,
void *user_data)
{
sprintf (draw_data + strlen (draw_data), "Z");
}
EXTERN void
_test_quadratic_to (void *dfuncs,
char *draw_data,
void *st,
float c1_x,
float c1_y,
float to_x,
float to_y,
void *user_data)
{
sprintf (draw_data + strlen (draw_data), "Q%g,%g %g,%g", c1_x, c1_y, to_x, to_y);
}
EXTERN void
_test_cubic_to (void *dfuncs,
char *draw_data,
void *st,
float c1_x,
float c1_y,
float c2_x,
float c2_y,
float to_x,
float to_y,
void *user_data)
{
sprintf (draw_data + strlen (draw_data), "C%g,%g %g,%g %g,%g", c1_x, c1_y, c2_x, c2_y, to_x, to_y);
}
}
harfbuzz-uharfbuzz-7a648c4/src/uharfbuzz/_face.pxi 0000664 0000000 0000000 00000120477 15266700675 0022344 0 ustar 00root root 0000000 0000000 class OTVarAxisFlags(IntFlag):
"""Flags for :class:`OTVarAxisInfo`.
.. attribute:: HIDDEN
:value: 0x01
The axis should not be exposed directly in user interfaces.
Wraps `hb_ot_var_axis_flags_t
`_.
"""
HIDDEN = HB_OT_VAR_AXIS_FLAG_HIDDEN
class OTVarAxisInfo(NamedTuple):
"""Data type for holding variation-axis values.
Wraps `hb_ot_var_axis_info_t
`_.
"""
axis_index: int
"""Index of the axis in the variation-axis array."""
tag: str
"""The tag identifying the design variation of the axis."""
name_id: int
"""The ``name`` table Name ID that provides display names for the axis."""
flags: OTVarAxisFlags
"""The :class:`OTVarAxisFlags` flags for the axis."""
min_value: float
"""The minimum value on the variation axis that the font covers."""
default_value: float
"""The position on the variation axis corresponding to the font's defaults."""
max_value: float
"""The maximum value on the variation axis that the font covers."""
class OTVarNamedInstance(NamedTuple):
"""A named instance defined in the font's ``fvar`` table."""
subfamily_name_id: int
"""The ``name`` table Name ID that provides display names for the
"Subfamily name" defined for the given named instance."""
postscript_name_id: int
"""The ``name`` table Name ID that provides display names for the
"PostScript name" defined for the given named instance."""
design_coords: List[float]
"""The design-space coordinates corresponding to the named instance."""
class Color(NamedTuple):
"""A color value. Colors are eight bits per channel RGB plus alpha
transparency.
Wraps `hb_color_t
`_.
"""
red: int
"""Red channel value."""
green: int
"""Green channel value."""
blue: int
"""Blue channel value."""
alpha: int
"""Alpha channel value."""
def to_int(self) -> int:
"""Returns an :class:`int` representation of this :class:`Color`."""
return HB_COLOR(self.blue, self.green, self.red, self.alpha)
@staticmethod
def from_int(value: int) -> Color:
"""Construct a :class:`Color` from an integer representation."""
r = hb_color_get_red(value)
g = hb_color_get_green(value)
b = hb_color_get_blue(value)
a = hb_color_get_alpha(value)
return Color(r, g, b, a)
class OTColor(Color):
"""A :class:`Color` from a font's color palette, together with its name
ID."""
name_id: int | None
class OTColorPaletteFlags(IntFlag):
"""Flags that describe the properties of a color palette.
.. attribute:: DEFAULT
:value: 0x00
Default indicating that there is nothing special to note about a
color palette.
.. attribute:: USABLE_WITH_LIGHT_BACKGROUND
:value: 0x01
Flag indicating that the color palette is appropriate to use when
displaying the font on a light background such as white.
.. attribute:: USABLE_WITH_DARK_BACKGROUND
:value: 0x02
Flag indicating that the color palette is appropriate to use when
displaying the font on a dark background such as black.
Wraps `hb_ot_color_palette_flags_t
`_.
"""
DEFAULT = HB_OT_COLOR_PALETTE_FLAG_DEFAULT
USABLE_WITH_LIGHT_BACKGROUND = HB_OT_COLOR_PALETTE_FLAG_USABLE_WITH_LIGHT_BACKGROUND
USABLE_WITH_DARK_BACKGROUND = HB_OT_COLOR_PALETTE_FLAG_USABLE_WITH_DARK_BACKGROUND
class OTColorPalette(NamedTuple):
"""A color palette from a font's ``CPAL`` table."""
colors: List[OTColor]
"""The colors that make up the palette."""
name_id: int | None
"""The ``name`` table Name ID that provides display names for the
palette, or ``None`` if no name is associated."""
flags: OTColorPaletteFlags
"""The :class:`OTColorPaletteFlags` flags for the palette."""
class OTColorLayer(NamedTuple):
"""A pair of glyph and color index.
A color index of ``0xFFFF`` does not refer to a palette color, but
indicates that the foreground color should be used.
Wraps `hb_ot_color_layer_t
`_.
"""
glyph: int
"""The glyph ID of the layer."""
color_index: int
"""The palette color index of the layer."""
class OTLayoutGlyphClass(IntEnum):
"""The GDEF classes defined for glyphs.
.. attribute:: UNCLASSIFIED
:value: 0
Glyphs not matching the other classifications.
.. attribute:: BASE_GLYPH
:value: 1
Spacing, single characters, capable of accepting marks.
.. attribute:: LIGATURE
:value: 2
Glyphs that represent ligation of multiple characters.
.. attribute:: MARK
:value: 3
Non-spacing, combining glyphs that represent marks.
.. attribute:: COMPONENT
:value: 4
Spacing glyphs that represent part of a single character.
Wraps `hb_ot_layout_glyph_class_t
`_.
"""
UNCLASSIFIED = HB_OT_LAYOUT_GLYPH_CLASS_UNCLASSIFIED
BASE_GLYPH = HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH
LIGATURE = HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE
MARK = HB_OT_LAYOUT_GLYPH_CLASS_MARK
COMPONENT = HB_OT_LAYOUT_GLYPH_CLASS_COMPONENT
cdef hb_user_data_key_t k
cdef hb_blob_t* _reference_table_func(
hb_face_t* face, hb_tag_t tag, void* user_data) noexcept:
cdef Face py_face = (hb_face_get_user_data(face, &k))
#
cdef char cstr[5]
hb_tag_to_string(tag, cstr)
cstr[4] = b'\0'
cdef bytes packed = cstr
#
cdef bytes table = py_face._reference_table_func(
py_face, packed.decode(), user_data)
if table is None:
return NULL
return hb_blob_create(
table, len(table), HB_MEMORY_MODE_READONLY, NULL, NULL)
cdef unsigned int _get_table_tags_func(
const hb_face_t* face,
unsigned int start_offset,
unsigned int* table_count,
hb_tag_t* table_tags,
void* user_data) noexcept:
cdef Face py_face = (hb_face_get_user_data(face, &k))
cdef list tags = py_face._get_table_tags_func(py_face, user_data)
cdef unsigned int population = len(tags)
cdef unsigned int end_offset
cdef unsigned int i
cdef bytes packed
if table_count is NULL:
return population
if start_offset >= population:
table_count[0] = 0
return population
end_offset = start_offset + table_count[0]
if end_offset < start_offset:
table_count[0] = 0
return population
if end_offset > population:
end_offset = population
table_count[0] = end_offset - start_offset
for i in range(start_offset, end_offset):
packed = tags[i].encode()
table_tags[i - start_offset] = hb_tag_from_string(packed, -1)
return population
class OTNameIdPredefined(IntEnum):
"""Predefined values for the OpenType ``name`` table Name ID.
.. attribute:: COPYRIGHT
Copyright notice.
.. attribute:: FONT_FAMILY
Font Family name.
.. attribute:: FONT_SUBFAMILY
Font Subfamily name.
.. attribute:: UNIQUE_ID
Unique font identifier.
.. attribute:: FULL_NAME
Full font name that reflects all family and relevant subfamily
descriptors.
.. attribute:: VERSION_STRING
Version string.
.. attribute:: POSTSCRIPT_NAME
PostScript name for the font.
.. attribute:: TRADEMARK
Trademark.
.. attribute:: MANUFACTURER
Manufacturer name.
.. attribute:: DESIGNER
Designer.
.. attribute:: DESCRIPTION
Description.
.. attribute:: VENDOR_URL
URL of font vendor.
.. attribute:: DESIGNER_URL
URL of typeface designer.
.. attribute:: LICENSE
License description.
.. attribute:: LICENSE_URL
License information URL.
.. attribute:: TYPOGRAPHIC_FAMILY
Typographic family name.
.. attribute:: TYPOGRAPHIC_SUBFAMILY
Typographic subfamily name.
.. attribute:: MAC_FULL_NAME
Compatible full name (Macintosh only).
.. attribute:: SAMPLE_TEXT
Sample text.
.. attribute:: CID_FINDFONT_NAME
PostScript CID findfont name.
.. attribute:: WWS_FAMILY
WWS family name.
.. attribute:: WWS_SUBFAMILY
WWS subfamily name.
.. attribute:: LIGHT_BACKGROUND
Light background palette.
.. attribute:: DARK_BACKGROUND
Dark background palette.
.. attribute:: VARIATIONS_PS_PREFIX
Variations PostScript name prefix.
.. attribute:: INVALID
Value to represent a nonexistent name ID.
Wraps `hb_ot_name_id_predefined_t
`_.
"""
COPYRIGHT = HB_OT_NAME_ID_COPYRIGHT
FONT_FAMILY = HB_OT_NAME_ID_FONT_FAMILY
FONT_SUBFAMILY = HB_OT_NAME_ID_FONT_SUBFAMILY
UNIQUE_ID = HB_OT_NAME_ID_UNIQUE_ID
FULL_NAME = HB_OT_NAME_ID_FULL_NAME
VERSION_STRING = HB_OT_NAME_ID_VERSION_STRING
POSTSCRIPT_NAME = HB_OT_NAME_ID_POSTSCRIPT_NAME
TRADEMARK = HB_OT_NAME_ID_TRADEMARK
MANUFACTURER = HB_OT_NAME_ID_MANUFACTURER
DESIGNER = HB_OT_NAME_ID_DESIGNER
DESCRIPTION = HB_OT_NAME_ID_DESCRIPTION
VENDOR_URL = HB_OT_NAME_ID_VENDOR_URL
DESIGNER_URL = HB_OT_NAME_ID_DESIGNER_URL
LICENSE = HB_OT_NAME_ID_LICENSE
LICENSE_URL = HB_OT_NAME_ID_LICENSE_URL
TYPOGRAPHIC_FAMILY = HB_OT_NAME_ID_TYPOGRAPHIC_FAMILY
TYPOGRAPHIC_SUBFAMILY = HB_OT_NAME_ID_TYPOGRAPHIC_SUBFAMILY
MAC_FULL_NAME = HB_OT_NAME_ID_MAC_FULL_NAME
SAMPLE_TEXT = HB_OT_NAME_ID_SAMPLE_TEXT
CID_FINDFONT_NAME = HB_OT_NAME_ID_CID_FINDFONT_NAME
WWS_FAMILY = HB_OT_NAME_ID_WWS_FAMILY
WWS_SUBFAMILY = HB_OT_NAME_ID_WWS_SUBFAMILY
LIGHT_BACKGROUND = HB_OT_NAME_ID_LIGHT_BACKGROUND
DARK_BACKGROUND = HB_OT_NAME_ID_DARK_BACKGROUND
VARIATIONS_PS_PREFIX = HB_OT_NAME_ID_VARIATIONS_PS_PREFIX
INVALID = HB_OT_NAME_ID_INVALID
class OTNameEntry(NamedTuple):
"""Structure representing a name ID in a particular language.
Wraps `hb_ot_name_entry_t
`_.
"""
name_id: OTNameIdPredefined | int
"""The name ID, as an :class:`OTNameIdPredefined` value or a raw
:class:`int` if it does not match any of the predefined ones."""
language: str | None
"""The BCP 47 language tag, or ``None`` if the language cannot be
determined."""
cdef class Face:
"""Font face objects.
A font face is an object that represents a single face from within a
font family. More precisely, a font face represents a single face in a
binary font file. Font faces are typically built from a binary blob and
a face index. Font faces are used to create fonts.
The face index is used for blobs of file formats such as TTC and DFont
that can contain more than one face. Face indices within such
collections are zero-based.
:param blob: A :class:`Blob` or :class:`bytes` containing the font data.
If ``None``, the empty face is returned.
:param index: The index of the face within the blob.
Wraps `hb_face_t
`_.
"""
cdef hb_face_t* _hb_face
cdef object _reference_table_func
cdef object _get_table_tags_func
cdef Blob _blob
def __cinit__(self, blob: Union[Blob, bytes] = None, int index=0):
if blob is not None:
if not isinstance(blob, Blob):
self._blob = Blob(blob)
else:
self._blob = blob
self._hb_face = hb_face_create(self._blob._hb_blob, index)
else:
self._hb_face = hb_face_get_empty()
self._blob = None
def __dealloc__(self):
hb_face_destroy(self._hb_face)
self._blob = None
@staticmethod
cdef Face from_ptr(hb_face_t* hb_face):
"""Create Face from a pointer, taking ownership of it."""
cdef Face wrapper = Face.__new__(Face)
wrapper._hb_face = hb_face
return wrapper
@classmethod
@deprecated("Face()", since="0.10.0")
def create(cls, blob: bytes, index: int = 0) -> Face:
cdef Face inst = cls(blob, index)
return inst
@classmethod
def create_for_tables(cls,
func: Callable[[
Face,
str, # tag
object # user_data
], bytes],
user_data: object) -> Face:
"""Variant of the normal constructor, built for those cases where it
is more convenient to provide data for individual tables instead of
the whole font data. With the caveat that :attr:`table_tags` would
not work with faces created this way. You can address that by
calling the :meth:`set_get_table_tags_func` method and setting the
appropriate callback.
Creates a new face object from the specified ``user_data`` and
``func``.
:param func: A callback that takes the :class:`Face`, a table tag,
and the ``user_data`` and returns the table data as
:class:`bytes`.
:param user_data: User data passed to ``func`` on each call.
Wraps `hb_face_create_for_tables()
`_.
"""
cdef Face inst = cls(None)
inst._hb_face = hb_face_create_for_tables(
_reference_table_func, user_data, NULL)
hb_face_set_user_data(inst._hb_face, &k, inst, NULL, 0)
inst._reference_table_func = func
return inst
@property
def count(self) -> int:
"""The number of faces in the blob.
Wraps `hb_face_count()
`_.
"""
return hb_face_count(self._blob._hb_blob)
@property
def index(self) -> int:
"""The face-index of this face.
Face indices within a collection are zero-based. Changing the index
has no effect on the face itself, only on the value returned by this
property.
Wraps `hb_face_get_index()
`_
/ `hb_face_set_index()
`_.
"""
return hb_face_get_index(self._hb_face)
@index.setter
def index(self, value: int):
hb_face_set_index(self._hb_face, value)
@property
def upem(self) -> int:
"""The units-per-em (UPEM) value of the face.
Typical UPEM values for fonts are 1000, or 2048, but any value in
between 16 and 16,384 is allowed for OpenType fonts.
Wraps `hb_face_get_upem()
`_
/ `hb_face_set_upem()
`_.
"""
return hb_face_get_upem(self._hb_face)
@upem.setter
def upem(self, value: int):
hb_face_set_upem(self._hb_face, value)
@property
def glyph_count(self) -> int:
"""The glyph-count value of the face.
Wraps `hb_face_get_glyph_count()
`_
/ `hb_face_set_glyph_count()
`_.
"""
return hb_face_get_glyph_count(self._hb_face)
@glyph_count.setter
def glyph_count(self, value: int):
hb_face_set_glyph_count(self._hb_face, value)
@property
def blob(self) -> Blob:
"""A :class:`Blob` containing the binary data of the face.
If referencing the face data is not possible, this property creates
a blob out of individual table blobs if :attr:`table_tags` works
with this face, otherwise it returns an empty blob.
:type: Blob
Wraps `hb_face_reference_blob()
`_.
"""
cdef hb_blob_t* blob = hb_face_reference_blob(self._hb_face)
if blob is NULL:
raise MemoryError()
return Blob.from_ptr(blob)
def reference_table(self, tag: str) -> Blob:
"""Fetches a reference to the specified table within the face.
:param tag: The four-character tag of the table to query.
:returns: A :class:`Blob` with the table data, or an empty blob if
referencing table data is not possible.
Wraps `hb_face_reference_table()
`_.
"""
cdef bytes packed = tag.encode()
cdef hb_tag_t hb_tag = hb_tag_from_string(packed, -1)
cdef hb_blob_t* blob = hb_face_reference_table(self._hb_face, hb_tag)
if blob is NULL:
raise MemoryError()
return Blob.from_ptr(blob)
def set_get_table_tags_func(self,
func: Callable[[Face, object], List[str]],
user_data: object = None):
"""Sets the implementation function for retrieving the table tags
of the face.
:param func: A callback that takes the :class:`Face` and the
``user_data`` and returns the list of table tags as
:class:`str`.
:param user_data: User data passed to ``func`` on each call.
Wraps `hb_face_set_get_table_tags_func()
`_.
"""
self._get_table_tags_func = func
hb_face_set_get_table_tags_func(
self._hb_face, _get_table_tags_func, user_data, NULL)
@property
def table_tags(self) -> List[str]:
"""A list of all table tags for the face, if possible.
:type: list[str]
Wraps `hb_face_get_table_tags()
`_.
"""
cdef unsigned int tag_count = STATIC_ARRAY_SIZE
cdef hb_tag_t tags_array[STATIC_ARRAY_SIZE]
cdef list tags = []
cdef char cstr[5]
cdef unsigned int i
cdef unsigned int start_offset = 0
while tag_count == STATIC_ARRAY_SIZE:
hb_face_get_table_tags(
self._hb_face, start_offset, &tag_count, tags_array)
for i in range(tag_count):
hb_tag_to_string(tags_array[i], cstr)
cstr[4] = b'\0'
packed = cstr
tags.append(packed.decode())
start_offset += tag_count
return tags
@property
def unicodes (self) -> Set[int]:
"""All Unicode characters covered by the face.
:type: Set
Wraps `hb_face_collect_unicodes()
`_.
"""
s = Set()
hb_face_collect_unicodes(self._hb_face, s._hb_set)
return s
@property
def variation_selectors(self) -> Set[int]:
"""All Unicode "Variation Selector" characters covered by the face.
:type: Set
Wraps `hb_face_collect_variation_selectors()
`_.
"""
s = Set()
hb_face_collect_variation_selectors(self._hb_face, s._hb_set)
return s
def variation_unicodes(self, variation_selector: int) -> Set[int]:
"""All Unicode characters for ``variation_selector`` covered by the
face.
:param variation_selector: The Variation Selector to query.
:returns: The :class:`Set` of Unicode characters.
Wraps `hb_face_collect_variation_unicodes()
`_.
"""
s = Set()
hb_face_collect_variation_unicodes(self._hb_face, variation_selector, s._hb_set)
return s
# variations
@property
def has_var_data(self) -> bool:
"""Whether the face includes any OpenType variation data in the
``fvar`` table.
Wraps `hb_ot_var_has_data()
`_.
"""
return hb_ot_var_has_data(self._hb_face)
@property
def axis_infos(self) -> List[OTVarAxisInfo]:
"""A list of all variation axes in the face.
:type: list[OTVarAxisInfo]
Wraps `hb_ot_var_get_axis_infos()
`_.
"""
cdef unsigned int axis_count = STATIC_ARRAY_SIZE
cdef hb_ot_var_axis_info_t axis_array[STATIC_ARRAY_SIZE]
cdef list infos = []
cdef char cstr[5]
cdef bytes packed
cdef unsigned int i
cdef unsigned int start_offset = 0
while axis_count == STATIC_ARRAY_SIZE:
hb_ot_var_get_axis_infos(
self._hb_face, start_offset, &axis_count, axis_array)
for i in range(axis_count):
hb_tag_to_string(axis_array[i].tag, cstr)
cstr[4] = b'\0'
packed = cstr
infos.append(
OTVarAxisInfo(
axis_index=axis_array[i].axis_index,
tag=packed.decode(),
name_id=axis_array[i].name_id,
flags=axis_array[i].flags,
min_value=axis_array[i].min_value,
default_value=axis_array[i].default_value,
max_value=axis_array[i].max_value
)
)
start_offset += axis_count
return infos
@property
def named_instances(self) -> List[OTVarNamedInstance]:
"""The named instances defined in the face's ``fvar`` table.
:type: list[OTVarNamedInstance]
Wraps `hb_ot_var_get_named_instance_count()
`_,
`hb_ot_var_named_instance_get_subfamily_name_id()
`_,
`hb_ot_var_named_instance_get_postscript_name_id()
`_,
and `hb_ot_var_named_instance_get_design_coords()
`_.
"""
instances = []
cdef hb_face_t* face = self._hb_face
cdef unsigned int instance_count = hb_ot_var_get_named_instance_count(face)
cdef unsigned int axis_count = hb_ot_var_get_axis_count(face)
cdef hb_ot_name_id_t subfamily_name_id
cdef hb_ot_name_id_t postscript_name_id
cdef float* coords = malloc(axis_count * sizeof(float))
cdef unsigned int coord_length
for i in range(instance_count):
coord_length = axis_count
hb_ot_var_named_instance_get_design_coords(face, i, &coord_length, coords)
instances.append(
OTVarNamedInstance(
subfamily_name_id=hb_ot_var_named_instance_get_subfamily_name_id(face, i),
postscript_name_id=hb_ot_var_named_instance_get_postscript_name_id(face, i),
design_coords=[coords[j] for j in range(coord_length)],
)
)
free(coords)
return instances
# math
@property
def has_math_data(self) -> bool:
"""Whether the face has a ``MATH`` table.
Wraps `hb_ot_math_has_data()
`_.
"""
return hb_ot_math_has_data(self._hb_face)
def is_glyph_extended_math_shape(self, glyph: int) -> bool:
"""Tests whether the given glyph index is an extended shape in the
face.
:param glyph: The glyph index to test.
:returns: ``True`` if the glyph is an extended shape, ``False``
otherwise.
Wraps `hb_ot_math_is_glyph_extended_shape()
`_.
"""
return hb_ot_math_is_glyph_extended_shape(self._hb_face, glyph)
# color
@property
def has_color_layers(self) -> bool:
"""Whether the face includes a ``COLR`` table with data according to
COLRv0.
Wraps `hb_ot_color_has_layers()
`_.
"""
return hb_ot_color_has_layers(self._hb_face)
def get_glyph_color_layers(self, glyph: int) -> List[OTColorLayer]:
"""Fetches a list of all color layers for the specified glyph index in
the face.
:param glyph: The glyph index to query.
:returns: The array of layers found.
Wraps `hb_ot_color_glyph_get_layers()
`_.
"""
cdef list ret = []
cdef unsigned int i
cdef unsigned int start_offset = 0
cdef unsigned int layer_count = STATIC_ARRAY_SIZE
cdef hb_ot_color_layer_t layers[STATIC_ARRAY_SIZE]
while layer_count == STATIC_ARRAY_SIZE:
hb_ot_color_glyph_get_layers(self._hb_face, glyph, start_offset, &layer_count, layers)
for i in range(layer_count):
ret.append(OTColorLayer(layers[i].glyph, layers[i].color_index))
start_offset += layer_count
return ret
@property
def has_color_palettes(self) -> bool:
"""Whether the face includes a ``CPAL`` color-palette table.
Wraps `hb_ot_color_has_palettes()
`_.
"""
return hb_ot_color_has_palettes(self._hb_face)
def get_color_palette(self, palette_index: int) -> OTColorPalette:
"""Fetches the color palette at the specified index.
:param palette_index: The index of the color palette.
:returns: An :class:`OTColorPalette` with the colors, name ID, and
flags of the palette.
Wraps `hb_ot_color_palette_get_colors()
`_,
`hb_ot_color_palette_get_name_id()
`_,
and `hb_ot_color_palette_get_flags()
`_.
"""
cdef hb_face_t* face = self._hb_face
cdef list colors = []
cdef unsigned int i
cdef unsigned int start_offset = 0
cdef unsigned int color_count = STATIC_ARRAY_SIZE
cdef hb_color_t c_colors[STATIC_ARRAY_SIZE]
while color_count == STATIC_ARRAY_SIZE:
hb_ot_color_palette_get_colors(face, palette_index, start_offset, &color_count, c_colors)
for i in range(color_count):
colors.append(Color.from_int(c_colors[i]))
return OTColorPalette(
colors=colors,
name_id=hb_ot_color_palette_get_name_id(face, palette_index),
flags=OTColorPaletteFlags(hb_ot_color_palette_get_flags(face, palette_index))
)
@property
def color_palettes(self) -> List[OTColorPalette]:
"""The face's color palettes.
:type: list[OTColorPalette]
Wraps `hb_ot_color_palette_get_count()
`_.
"""
cdef list palettes = []
cdef unsigned int palette_count = hb_ot_color_palette_get_count(self._hb_face)
for i in range(palette_count):
palettes.append(self.get_color_palette(i))
return palettes
def color_palette_color_get_name_id(self, color_index: int) -> int | None:
"""Fetches the ``name`` table Name ID that provides display names
for the specified color in the face's ``CPAL`` color palette.
:param color_index: The index of the color.
:returns: The Name ID, or ``None`` if the color is not named.
Wraps `hb_ot_color_palette_color_get_name_id()
`_.
"""
cdef hb_ot_name_id_t name_id
name_id = hb_ot_color_palette_color_get_name_id(self._hb_face, color_index)
if name_id == HB_OT_NAME_ID_INVALID:
return None
return name_id
@property
def has_color_paint(self) -> bool:
"""Whether the face includes a ``COLR`` table with data according to
COLRv1.
Wraps `hb_ot_color_has_paint()
`_.
"""
return hb_ot_color_has_paint(self._hb_face)
def glyph_has_color_paint(self, glyph: int) -> bool:
"""Tests whether the face includes COLRv1 paint data for ``glyph``.
:param glyph: The glyph index to query.
:returns: ``True`` if data is found, ``False`` otherwise.
Wraps `hb_ot_color_glyph_has_paint()
`_.
"""
return hb_ot_color_glyph_has_paint(self._hb_face, glyph)
@property
def has_color_svg(self) -> bool:
"""Whether the face includes any ``SVG`` glyph images.
Wraps `hb_ot_color_has_svg()
`_.
"""
return hb_ot_color_has_svg(self._hb_face)
def get_glyph_color_svg(self, glyph: int) -> Blob:
"""Fetches the SVG document for a glyph. The blob may be either
plain text or gzip-encoded.
If the glyph has no SVG document, the singleton empty blob is
returned.
:param glyph: An SVG glyph index.
:returns: A :class:`Blob` with the content of the SVG document.
Wraps `hb_ot_color_glyph_reference_svg()
`_.
"""
cdef hb_blob_t* blob
blob = hb_ot_color_glyph_reference_svg(self._hb_face, glyph)
return Blob.from_ptr(blob)
@property
def has_color_png(self) -> bool:
"""Whether the face has PNG glyph images (either in ``CBDT`` or
``sbix`` tables).
Wraps `hb_ot_color_has_png()
`_.
"""
return hb_ot_color_has_png(self._hb_face)
# layout
@property
def has_layout_glyph_classes(self) -> bool:
"""Whether the face has any glyph classes defined in its GDEF table.
Wraps `hb_ot_layout_has_glyph_classes()
`_.
"""
return hb_ot_layout_has_glyph_classes(self._hb_face)
def get_layout_glyph_class(self, glyph: int) -> OTLayoutGlyphClass:
"""Fetches the GDEF class of the requested glyph.
:param glyph: The glyph code point to query.
:returns: The :class:`OTLayoutGlyphClass` glyph class of the given
code point in the GDEF table of the face.
Wraps `hb_ot_layout_get_glyph_class()
`_.
"""
return OTLayoutGlyphClass(hb_ot_layout_get_glyph_class(self._hb_face, glyph))
@property
def has_layout_positioning(self) -> bool:
"""Whether the face includes any GPOS positioning.
Wraps `hb_ot_layout_has_positioning()
`_.
"""
return hb_ot_layout_has_positioning(self._hb_face)
@property
def has_layout_substitution(self) -> bool:
"""Whether the face includes any GSUB substitutions.
Wraps `hb_ot_layout_has_substitution()
`_.
"""
return hb_ot_layout_has_substitution(self._hb_face)
def get_lookup_glyph_alternates(self, lookup_index: int, glyph: int) -> List[int]:
"""Fetches alternates of a glyph from a given GSUB lookup index.
:param lookup_index: Index of the feature lookup to query.
:param glyph: A glyph id.
:returns: Alternate glyphs associated with the glyph id.
Wraps `hb_ot_layout_lookup_get_glyph_alternates()
`_.
"""
cdef list alternates = []
cdef unsigned int i
cdef unsigned int start_offset = 0
cdef unsigned int alternate_count = STATIC_ARRAY_SIZE
cdef hb_codepoint_t c_alternates[STATIC_ARRAY_SIZE]
while alternate_count == STATIC_ARRAY_SIZE:
hb_ot_layout_lookup_get_glyph_alternates(self._hb_face, lookup_index, glyph, start_offset,
&alternate_count, c_alternates)
for i in range(alternate_count):
alternates.append(c_alternates[i])
start_offset += alternate_count
return alternates
def get_language_feature_tags(self,
tag: str,
script_index: int = 0,
language_index: int = 0xFFFF) -> List[str]:
"""Fetches a list of all features in the face's GSUB or GPOS table.
:param tag: ``"GSUB"`` or ``"GPOS"``.
:param script_index: The index of the requested script tag.
:param language_index: The index of the requested language tag.
:returns: The array of feature tags found for the query.
Wraps `hb_ot_layout_language_get_feature_tags()
`_.
"""
cdef bytes packed = tag.encode()
cdef hb_tag_t hb_tag = hb_tag_from_string(packed, -1)
cdef unsigned int feature_count = STATIC_ARRAY_SIZE
cdef hb_tag_t c_tags[STATIC_ARRAY_SIZE]
cdef list tags = []
cdef char cstr[5]
cdef unsigned int i
cdef unsigned int start_offset = 0
while feature_count == STATIC_ARRAY_SIZE:
hb_ot_layout_language_get_feature_tags(
self._hb_face,
hb_tag, script_index,
language_index,
start_offset,
&feature_count,
c_tags)
for i in range(feature_count):
hb_tag_to_string(c_tags[i], cstr)
cstr[4] = b'\0'
packed = cstr
tags.append(packed.decode())
start_offset += feature_count
return tags
def get_script_language_tags(self, tag: str, script_index: int = 0) -> List[str]:
"""Fetches a list of language tags in the face's GSUB or GPOS table,
underneath the specified script index.
:param tag: ``"GSUB"`` or ``"GPOS"``.
:param script_index: The index of the requested script tag.
:returns: Array of language tags found in the table.
Wraps `hb_ot_layout_script_get_language_tags()
`_.
"""
cdef bytes packed = tag.encode()
cdef hb_tag_t hb_tag = hb_tag_from_string(packed, -1)
cdef unsigned int language_count = STATIC_ARRAY_SIZE
cdef hb_tag_t c_tags[STATIC_ARRAY_SIZE]
cdef list tags = []
cdef char cstr[5]
cdef unsigned int i
cdef unsigned int start_offset = 0
while language_count == STATIC_ARRAY_SIZE:
hb_ot_layout_script_get_language_tags(
self._hb_face,
hb_tag,
script_index,
start_offset,
&language_count,
c_tags)
for i in range(language_count):
hb_tag_to_string(c_tags[i], cstr)
cstr[4] = b'\0'
packed = cstr
tags.append(packed.decode())
start_offset += language_count
return tags
def get_table_script_tags(self, tag: str) -> List[str]:
"""Fetches a list of all scripts enumerated in the specified face's
GSUB or GPOS table.
:param tag: ``"GSUB"`` or ``"GPOS"``.
:returns: The array of script tags found for the query.
Wraps `hb_ot_layout_table_get_script_tags()
`_.
"""
cdef bytes packed = tag.encode()
cdef hb_tag_t hb_tag = hb_tag_from_string(packed, -1)
cdef unsigned int script_count = STATIC_ARRAY_SIZE
cdef hb_tag_t c_tags[STATIC_ARRAY_SIZE]
cdef list tags = []
cdef char cstr[5]
cdef unsigned int i
cdef unsigned int start_offset = 0
while script_count == STATIC_ARRAY_SIZE:
hb_ot_layout_table_get_script_tags(
self._hb_face,
hb_tag,
start_offset,
&script_count,
c_tags)
for i in range(script_count):
hb_tag_to_string(c_tags[i], cstr)
cstr[4] = b'\0'
packed = cstr
tags.append(packed.decode())
start_offset += script_count
return tags
def list_names(self) -> List[OTNameEntry]:
"""Enumerates all available name IDs and language combinations.
:returns: Array of available name entries.
Wraps `hb_ot_name_list_names()
`_.
"""
cdef list ret = []
cdef unsigned int num_entries
cdef const hb_ot_name_entry_t* entries
cdef unsigned int i
cdef const_char *cstr
cdef bytes packed
entries = hb_ot_name_list_names(self._hb_face, &num_entries)
for i in range(num_entries):
cstr = hb_language_to_string(entries[i].language)
if cstr is NULL:
language = None
else:
packed = cstr
language = packed.decode()
if entries[i].name_id in iter(OTNameIdPredefined):
name_id = OTNameIdPredefined(entries[i].name_id)
else:
name_id = entries[i].name_id
ret.append(OTNameEntry(name_id=name_id, language=language))
return ret
def get_name(self, name_id: OTNameIdPredefined | int, language: str | None = None) -> str | None:
"""Fetches a font name from the OpenType ``name`` table.
:param name_id: The OpenType name identifier to fetch.
:param language: The BCP 47 language tag to fetch the name for. If
``None``, English (``"en"``) is assumed.
:returns: The name as a :class:`str`, or ``None`` if not found.
Wraps `hb_ot_name_get_utf8()
