pcffont 0.0.1__py3-none-any.whl

pcffont/__init__.py

@@ -0,0 +1,10 @@
+from pcffont.font import PcfFont
+from pcffont.header import PcfTableType
+from pcffont.metric import PcfMetric
+from pcffont.t_properties import PcfProperties
+from pcffont.t_accelerators import PcfAccelerators
+from pcffont.t_metrics import PcfMetrics
+from pcffont.t_bitmaps import PcfBitmaps
+from pcffont.t_encodings import PcfBdfEncodings
+from pcffont.t_scalable_widths import PcfScalableWidths
+from pcffont.t_glyph_names import PcfGlyphNames

pcffont/error.py

@@ -0,0 +1,25 @@
+
+class PcfError(Exception):
+    pass
+
+
+class PcfPropKeyError(PcfError):
+    def __init__(self, key: str, reason: str):
+        self.key = key
+        self.reason = reason
+        super().__init__(f"'{key}': {reason}")
+
+
+class PcfPropValueError(PcfError):
+    def __init__(self, key: str, value: object, reason: str):
+        self.key = key
+        self.value = value
+        self.reason = reason
+        super().__init__(f"'{key}': '{value}': {reason}")
+
+
+class PcfXlfdError(PcfError):
+    def __init__(self, font_name: str, reason: str):
+        self.font_name = font_name
+        self.reason = reason
+        super().__init__(f"'{font_name}': {reason}")

pcffont/font.py

@@ -0,0 +1,143 @@
+import os
+from collections import UserDict
+from typing import BinaryIO
+
+from pcffont.error import PcfError
+from pcffont.header import PcfTableType, PcfHeader
+from pcffont.internal import util
+from pcffont.internal.buffer import Buffer
+from pcffont.t_accelerators import PcfAccelerators
+from pcffont.t_bitmaps import PcfBitmaps
+from pcffont.t_encodings import PcfBdfEncodings
+from pcffont.t_glyph_names import PcfGlyphNames
+from pcffont.t_metrics import PcfMetrics
+from pcffont.t_properties import PcfProperties
+from pcffont.t_scalable_widths import PcfScalableWidths
+from pcffont.table import PcfTable
+
+
+class PcfFont(UserDict[PcfTableType, PcfTable]):
+    @staticmethod
+    def parse(stream: BinaryIO) -> 'PcfFont':
+        buffer = Buffer(stream)
+
+        headers = PcfHeader.parse(buffer)
+
+        tables = {}
+        for header in headers:
+            if header.table_type in tables:
+                raise PcfError(f"Duplicate table '{header.table_type.name}'")
+            tables[header.table_type] = util.parse_table(buffer, header)
+
+        return PcfFont(tables)
+
+    @staticmethod
+    def load(file_path: str | bytes | os.PathLike[str] | os.PathLike[bytes]) -> 'PcfFont':
+        with open(file_path, 'rb') as file:
+            return PcfFont.parse(file)
+
+    def __init__(self, tables: dict[PcfTableType, PcfTable | None] = None):
+        super().__init__(tables)
+
+    def __setitem__(self, table_type: PcfTableType, table: PcfTable | None):
+        if table is None:
+            self.pop(table_type, None)
+        else:
+            if not isinstance(table, util.TABLE_TYPE_REGISTRY[table_type]):
+                raise PcfError(f"Mismatched table type: '{table_type.name}' -> '{type(table)}'")
+            super().__setitem__(table_type, table)
+
+    def __repr__(self) -> str:
+        return object.__repr__(self)
+
+    @property
+    def properties(self) -> PcfProperties | None:
+        return self.get(PcfTableType.PROPERTIES, None)
+
+    @properties.setter
+    def properties(self, table: PcfProperties | None):
+        self[PcfTableType.PROPERTIES] = table
+
+    @property
+    def accelerators(self) -> PcfAccelerators | None:
+        return self.get(PcfTableType.ACCELERATORS, None)
+
+    @accelerators.setter
+    def accelerators(self, table: PcfAccelerators | None):
+        self[PcfTableType.ACCELERATORS] = table
+
+    @property
+    def metrics(self) -> PcfMetrics | None:
+        return self.get(PcfTableType.METRICS, None)
+
+    @metrics.setter
+    def metrics(self, table: PcfMetrics | None):
+        self[PcfTableType.METRICS] = table
+
+    @property
+    def bitmaps(self) -> PcfBitmaps | None:
+        return self.get(PcfTableType.BITMAPS, None)
+
+    @bitmaps.setter
+    def bitmaps(self, table: PcfBitmaps | None):
+        self[PcfTableType.BITMAPS] = table
+
+    @property
+    def ink_metrics(self) -> PcfMetrics | None:
+        return self.get(PcfTableType.INK_METRICS, None)
+
+    @ink_metrics.setter
+    def ink_metrics(self, table: PcfMetrics | None):
+        self[PcfTableType.INK_METRICS] = table
+
+    @property
+    def bdf_encodings(self) -> PcfBdfEncodings | None:
+        return self.get(PcfTableType.BDF_ENCODINGS, None)
+
+    @bdf_encodings.setter
+    def bdf_encodings(self, table: PcfBdfEncodings | None):
+        self[PcfTableType.BDF_ENCODINGS] = table
+
+    @property
+    def scalable_widths(self) -> PcfScalableWidths | None:
+        return self.get(PcfTableType.SWIDTHS, None)
+
+    @scalable_widths.setter
+    def scalable_widths(self, table: PcfScalableWidths | None):
+        self[PcfTableType.SWIDTHS] = table
+
+    @property
+    def glyph_names(self) -> PcfGlyphNames | None:
+        return self.get(PcfTableType.GLYPH_NAMES, None)
+
+    @glyph_names.setter
+    def glyph_names(self, table: PcfGlyphNames | None):
+        self[PcfTableType.GLYPH_NAMES] = table
+
+    @property
+    def bdf_accelerators(self) -> PcfAccelerators | None:
+        return self.get(PcfTableType.BDF_ACCELERATORS, None)
+
+    @bdf_accelerators.setter
+    def bdf_accelerators(self, table: PcfAccelerators | None):
+        self[PcfTableType.BDF_ACCELERATORS] = table
+
+    def dump(self, stream: BinaryIO, compat_mode: bool = False):
+        buffer = Buffer(stream)
+
+        headers = []
+        table_offset = 4 + 4 + (4 * 4) * len(self)
+        for table_type, table in sorted(self.items()):
+            table_size = table.dump(buffer, table_offset, compat_mode)
+            headers.append(PcfHeader(table_type, table.table_format, table_size, table_offset))
+            table_offset += table_size
+
+        PcfHeader.dump(buffer, headers)
+
+    def save(
+            self,
+            file_path: str | bytes | os.PathLike[str] | os.PathLike[bytes],
+            compat_mode: bool = False,
+    ):
+        with open(file_path, 'wb') as file:
+            self.dump(file, compat_mode)

pcffont/header.py

@@ -0,0 +1,70 @@
+from enum import IntEnum, IntFlag
+
+from pcffont.error import PcfError
+from pcffont.internal.buffer import Buffer
+
+_MAGIC_STRING = b'\x01fcp'
+
+
+class PcfTableType(IntEnum):
+    PROPERTIES = 1 << 0
+    ACCELERATORS = 1 << 1
+    METRICS = 1 << 2
+    BITMAPS = 1 << 3
+    INK_METRICS = 1 << 4
+    BDF_ENCODINGS = 1 << 5
+    SWIDTHS = 1 << 6
+    GLYPH_NAMES = 1 << 7
+    BDF_ACCELERATORS = 1 << 8
+
+
+class PcfTableFormat(IntFlag):
+    DEFAULT_FORMAT = 0b_0000_0000_0000
+    INKBOUNDS = 0b_0010_0000_0000
+    ACCEL_W_INKBOUNDS = 0b_0001_0000_0000
+    COMPRESSED_METRICS = 0b_0001_0000_0000
+
+
+class PcfTableFormatMask(IntFlag):
+    GLYPH_PAD = 0b_0000_0011
+    BYTE = 0b_0000_0100
+    BIT = 0b_0000_1000
+    SCAN_UNIT = 0b_0011_0000
+
+
+class PcfHeader:
+    @staticmethod
+    def parse(buffer: Buffer) -> list['PcfHeader']:
+        buffer.seek(0)
+        if buffer.read(4) != _MAGIC_STRING:
+            raise PcfError('Not PCF format')
+
+        tables_count = buffer.read_int32_le()
+
+        headers = []
+        for _ in range(tables_count):
+            table_type = PcfTableType(buffer.read_int32_le())
+            table_format = buffer.read_int32_le()
+            table_size = buffer.read_int32_le()
+            table_offset = buffer.read_int32_le()
+            headers.append(PcfHeader(table_type, table_format, table_size, table_offset))
+
+        return headers
+
+    @staticmethod
+    def dump(buffer: Buffer, headers: list['PcfHeader']):
+        buffer.seek(0)
+        buffer.write(_MAGIC_STRING)
+
+        buffer.write_int32_le(len(headers))
+        for header in headers:
+            buffer.write_int32_le(header.table_type)
+            buffer.write_int32_le(header.table_format)
+            buffer.write_int32_le(header.table_size)
+            buffer.write_int32_le(header.table_offset)
+
+    def __init__(self, table_type: PcfTableType, table_format: int, table_size: int, table_offset: int):
+        self.table_type = table_type
+        self.table_format = table_format
+        self.table_size = table_size
+        self.table_offset = table_offset

pcffont/internal/buffer.py

@@ -0,0 +1,122 @@
+from typing import BinaryIO, Literal, TypeAlias
+
+# TODO # type ByteOrder = Literal['little', 'big']
+ByteOrder: TypeAlias = Literal['little', 'big']
+
+
+class Buffer:
+    def __init__(self, stream: BinaryIO):
+        self.stream = stream
+
+    def read(self, n: int) -> bytes:
+        return self.stream.read(n)
+
+    def read_int(self, n: int, byte_order: ByteOrder) -> int:
+        return int.from_bytes(self.read(n), byte_order)
+
+    def read_int_le(self, n: int) -> int:
+        return self.read_int(n, 'little')
+
+    def read_int_be(self, n: int) -> int:
+        return self.read_int(n, 'big')
+
+    def read_int32(self, byte_order: ByteOrder) -> int:
+        return self.read_int(4, byte_order)
+
+    def read_int32_le(self) -> int:
+        return self.read_int32('little')
+
+    def read_int32_be(self) -> int:
+        return self.read_int32('big')
+
+    def read_int16(self, byte_order: ByteOrder) -> int:
+        return self.read_int(2, byte_order)
+
+    def read_int16_le(self) -> int:
+        return self.read_int16('little')
+
+    def read_int16_be(self) -> int:
+        return self.read_int16('big')
+
+    def read_int8(self, byte_order: ByteOrder) -> int:
+        return self.read_int(1, byte_order)
+
+    def read_int8_le(self) -> int:
+        return self.read_int8('little')
+
+    def read_int8_be(self) -> int:
+        return self.read_int8('big')
+
+    def read_bool(self) -> bool:
+        return self.read(1) != b'\x00'
+
+    def read_string(self) -> str:
+        data = bytearray()
+        while True:
+            b = self.read(1)
+            if b == b'\x00' or b == b'':
+                break
+            data.extend(b)
+        return data.decode('utf-8')
+
+    def write(self, s: bytes) -> int:
+        return self.stream.write(s)
+
+    def write_int(self, i: int, n: int, byte_order: ByteOrder) -> int:
+        return self.write(i.to_bytes(n, byte_order))
+
+    def write_int_le(self, i: int, n: int) -> int:
+        return self.write_int(i, n, 'little')
+
+    def write_int_be(self, i: int, n: int) -> int:
+        return self.write_int(i, n, 'big')
+
+    def write_int32(self, i: int, byte_order: ByteOrder) -> int:
+        return self.write_int(i, 4, byte_order)
+
+    def write_int32_le(self, i: int) -> int:
+        return self.write_int32(i, 'little')
+
+    def write_int32_be(self, i: int) -> int:
+        return self.write_int32(i, 'big')
+
+    def write_int16(self, i: int, byte_order: ByteOrder) -> int:
+        return self.write_int(i, 2, byte_order)
+
+    def write_int16_le(self, i: int) -> int:
+        return self.write_int16(i, 'little')
+
+    def write_int16_be(self, i: int) -> int:
+        return self.write_int16(i, 'big')
+
+    def write_int8(self, i: int, byte_order: ByteOrder) -> int:
+        return self.write_int(i, 1, byte_order)
+
+    def write_int8_le(self, i: int) -> int:
+        return self.write_int8(i, 'little')
+
+    def write_int8_be(self, i: int) -> int:
+        return self.write_int8(i, 'big')
+
+    def write_bool(self, b: bool) -> int:
+        return self.write(b'\x01' if b else b'\x00')
+
+    def write_nulls(self, n: int) -> int:
+        for _ in range(n):
+            self.write(b'\x00')
+        return n
+
+    def write_string(self, s: str) -> int:
+        return self.write(s.encode('utf-8')) + self.write_nulls(1)
+
+    def skip(self, n: int):
+        self.seek(self.tell() + n)
+
+    def skip_int(self):
+        self.skip(4)
+
+    def seek(self, offset: int):
+        self.stream.seek(offset)
+
+    def tell(self) -> int:
+        return self.stream.tell()

pcffont/internal/util.py

@@ -0,0 +1,49 @@
+from pcffont.error import PcfError
+from pcffont.header import PcfTableType, PcfTableFormatMask, PcfHeader
+from pcffont.internal.buffer import ByteOrder, Buffer
+from pcffont.t_accelerators import PcfAccelerators
+from pcffont.t_bitmaps import PcfBitmaps
+from pcffont.t_encodings import PcfBdfEncodings
+from pcffont.t_glyph_names import PcfGlyphNames
+from pcffont.t_metrics import PcfMetrics
+from pcffont.t_properties import PcfProperties
+from pcffont.t_scalable_widths import PcfScalableWidths
+from pcffont.table import PcfTable
+
+TABLE_TYPE_REGISTRY = {
+    PcfTableType.PROPERTIES: PcfProperties,
+    PcfTableType.ACCELERATORS: PcfAccelerators,
+    PcfTableType.METRICS: PcfMetrics,
+    PcfTableType.BITMAPS: PcfBitmaps,
+    PcfTableType.INK_METRICS: PcfMetrics,
+    PcfTableType.BDF_ENCODINGS: PcfBdfEncodings,
+    PcfTableType.SWIDTHS: PcfScalableWidths,
+    PcfTableType.GLYPH_NAMES: PcfGlyphNames,
+    PcfTableType.BDF_ACCELERATORS: PcfAccelerators,
+}
+
+
+def parse_table(buffer: Buffer, header: PcfHeader) -> PcfTable | None:
+    clz = TABLE_TYPE_REGISTRY.get(header.table_type, None)
+    if clz is not None:
+        return clz.parse(buffer, header)
+    return None
+
+
+def read_and_check_table_format(buffer: Buffer, header: PcfHeader) -> int:
+    buffer.seek(header.table_offset)
+    table_format = buffer.read_int32_le()
+    if table_format != header.table_format:
+        raise PcfError(f"The table format definition is inconsistent with the header: type '{header.table_type.name}', offset {header.table_offset}")
+    return table_format
+
+
+def get_table_byte_order(table_format: int) -> ByteOrder:
+    byte_mask = table_format & PcfTableFormatMask.BYTE > 0
+    bit_mask = table_format & PcfTableFormatMask.BIT > 0
+    if byte_mask and bit_mask:
+        return 'big'
+    elif (not byte_mask) and (not bit_mask):
+        return 'little'
+    else:
+        raise PcfError(f'Table format not supported: {table_format:b}')

pcffont/metric.py

@@ -0,0 +1,59 @@
+from pcffont.internal.buffer import ByteOrder, Buffer
+
+
+class PcfMetric:
+    @staticmethod
+    def parse(buffer: Buffer, byte_order: ByteOrder, is_compressed: bool) -> 'PcfMetric':
+        if is_compressed:
+            left_sided_bearing = buffer.read_int8(byte_order)
+            right_side_bearing = buffer.read_int8(byte_order)
+            character_width = buffer.read_int8(byte_order)
+            character_ascent = buffer.read_int8(byte_order)
+            character_descent = buffer.read_int8(byte_order)
+            character_attributes = 0
+        else:
+            left_sided_bearing = buffer.read_int16(byte_order)
+            right_side_bearing = buffer.read_int16(byte_order)
+            character_width = buffer.read_int16(byte_order)
+            character_ascent = buffer.read_int16(byte_order)
+            character_descent = buffer.read_int16(byte_order)
+            character_attributes = buffer.read_int16(byte_order)
+        return PcfMetric(
+            left_sided_bearing,
+            right_side_bearing,
+            character_width,
+            character_ascent,
+            character_descent,
+            character_attributes,
+        )
+
+    def __init__(
+            self,
+            left_sided_bearing: int,
+            right_side_bearing: int,
+            character_width: int,
+            character_ascent: int,
+            character_descent: int,
+            character_attributes: int = 0,
+    ):
+        self.left_sided_bearing = left_sided_bearing
+        self.right_side_bearing = right_side_bearing
+        self.character_width = character_width
+        self.character_ascent = character_ascent
+        self.character_descent = character_descent
+        self.character_attributes = character_attributes
+
+    def dump(self, buffer: Buffer, byte_order: ByteOrder, is_compressed: bool):
+        if is_compressed:
+            buffer.write_int8(self.left_sided_bearing, byte_order)
+            buffer.write_int8(self.right_side_bearing, byte_order)
+            buffer.write_int8(self.character_width, byte_order)
+            buffer.write_int8(self.character_ascent, byte_order)
+            buffer.write_int8(self.character_descent, byte_order)
+        else:
+            buffer.write_int16(self.left_sided_bearing, byte_order)
+            buffer.write_int16(self.right_side_bearing, byte_order)
+            buffer.write_int16(self.character_width, byte_order)
+            buffer.write_int16(self.character_ascent, byte_order)
+            buffer.write_int16(self.character_descent, byte_order)
+            buffer.write_int16(self.character_attributes, byte_order)

pcffont/t_accelerators.py

@@ -0,0 +1,143 @@
+from pcffont.header import PcfTableFormat, PcfHeader
+from pcffont.internal import util
+from pcffont.internal.buffer import Buffer
+from pcffont.metric import PcfMetric
+from pcffont.table import PcfTable
+
+
+class PcfAccelerators(PcfTable):
+    @staticmethod
+    def parse(buffer: Buffer, header: PcfHeader) -> 'PcfAccelerators':
+        table_format = util.read_and_check_table_format(buffer, header)
+        byte_order = util.get_table_byte_order(table_format)
+        is_accel_w_ink_bounds = table_format & PcfTableFormat.ACCEL_W_INKBOUNDS > 0
+
+        no_overlap = buffer.read_bool()
+        constant_metrics = buffer.read_bool()
+        terminal_font = buffer.read_bool()
+        constant_width = buffer.read_bool()
+        ink_inside = buffer.read_bool()
+        ink_metrics = buffer.read_bool()
+        draw_direction_right_to_left = buffer.read_bool()
+        buffer.skip(1)
+        font_ascent = buffer.read_int32(byte_order)
+        font_descent = buffer.read_int32(byte_order)
+        max_overlap = buffer.read_int32(byte_order)
+
+        min_bounds = PcfMetric.parse(buffer, byte_order, False)
+        max_bounds = PcfMetric.parse(buffer, byte_order, False)
+
+        _ink_bounds_chunk = None  # TODO
+        _padding_chunk_info = None  # TODO
+
+        if is_accel_w_ink_bounds:
+            ink_min_bounds = PcfMetric.parse(buffer, byte_order, False)
+            ink_max_bounds = PcfMetric.parse(buffer, byte_order, False)
+        else:
+            ink_min_bounds = None
+            ink_max_bounds = None
+            # TODO
+            if header.table_size >= buffer.tell() - header.table_offset + 2 * 6 * 2:
+                _ink_bounds_chunk = buffer.read(2 * 6 * 2)
+
+        # TODO
+        _padding = header.table_size - (buffer.tell() - header.table_offset)
+        if _padding > 0:
+            _padding_chunk_info = buffer.read(_padding), _padding
+
+        return PcfAccelerators(
+            table_format,
+            no_overlap,
+            constant_metrics,
+            terminal_font,
+            constant_width,
+            ink_inside,
+            ink_metrics,
+            draw_direction_right_to_left,
+            font_ascent,
+            font_descent,
+            max_overlap,
+            min_bounds,
+            max_bounds,
+            ink_min_bounds,
+            ink_max_bounds,
+            _ink_bounds_chunk,  # TODO
+            _padding_chunk_info,  # TODO
+        )
+
+    def __init__(
+            self,
+            table_format: int = PcfTable.DEFAULT_TABLE_FORMAT,
+            no_overlap: bool = False,
+            constant_metrics: bool = False,
+            terminal_font: bool = False,
+            constant_width: bool = False,
+            ink_inside: bool = False,
+            ink_metrics: bool = False,
+            draw_direction_right_to_left: bool = False,
+            font_ascent: int = 0,
+            font_descent: int = 0,
+            max_overlap: int = 0,
+            min_bounds: PcfMetric = None,
+            max_bounds: PcfMetric = None,
+            ink_min_bounds: PcfMetric = None,
+            ink_max_bounds: PcfMetric = None,
+            _ink_bounds_chunk: bytes = None,  # TODO
+            _padding_chunk_info: tuple[bytes, int] = None,  # TODO
+    ):
+        super().__init__(table_format)
+        self.no_overlap = no_overlap
+        self.constant_metrics = constant_metrics
+        self.terminal_font = terminal_font
+        self.constant_width = constant_width
+        self.ink_inside = ink_inside
+        self.ink_metrics = ink_metrics
+        self.draw_direction_right_to_left = draw_direction_right_to_left
+        self.font_ascent = font_ascent
+        self.font_descent = font_descent
+        self.max_overlap = max_overlap
+        self.min_bounds = min_bounds
+        self.max_bounds = max_bounds
+        self.ink_min_bounds = ink_min_bounds
+        self.ink_max_bounds = ink_max_bounds
+        self._ink_bounds_chunk = _ink_bounds_chunk  # TODO
+        self._padding_chunk_info = _padding_chunk_info  # TODO
+
+    def _dump(self, buffer: Buffer, table_offset: int, compat_mode: bool = False) -> int:
+        byte_order = util.get_table_byte_order(self.table_format)
+        is_accel_w_ink_bounds = self.table_format & PcfTableFormat.ACCEL_W_INKBOUNDS > 0
+
+        buffer.seek(table_offset)
+        buffer.write_int32_le(self.table_format)
+        buffer.write_bool(self.no_overlap)
+        buffer.write_bool(self.constant_metrics)
+        buffer.write_bool(self.terminal_font)
+        buffer.write_bool(self.constant_width)
+        buffer.write_bool(self.ink_inside)
+        buffer.write_bool(self.ink_metrics)
+        buffer.write_bool(self.draw_direction_right_to_left)
+        buffer.write_nulls(1)
+        buffer.write_int32(self.font_ascent, byte_order)
+        buffer.write_int32(self.font_descent, byte_order)
+        buffer.write_int32(self.max_overlap, byte_order)
+
+        self.min_bounds.dump(buffer, byte_order, False)
+        self.max_bounds.dump(buffer, byte_order, False)
+
+        if is_accel_w_ink_bounds:
+            self.ink_min_bounds.dump(buffer, byte_order, False)
+            self.ink_max_bounds.dump(buffer, byte_order, False)
+        else:
+            # TODO
+            if compat_mode and self._ink_bounds_chunk is not None:
+                buffer.write(self._ink_bounds_chunk)
+
+        table_size = buffer.tell() - table_offset
+
+        # TODO
+        if compat_mode and self._padding_chunk_info is not None:
+            _padding_chunk, _padding = self._padding_chunk_info
+            buffer.write(_padding_chunk)
+            table_size += _padding
+
+        return table_size