kitepdf-core/io.github.yuroyami.kitepdf.core.font/PdfFont

PdfFont

A resolved PDF font.

The font knows how to:

decode show-text bytes into unicode (text extraction).
layoutBytes walk show-text bytes into a sequence of TextGlyphs, each tagged with its outline (if any), advance, and decoded text.

Simple fonts (Type 1, TrueType, Type1C, Type 3) consume one byte per glyph. Type 0 composite fonts (CIDFontType0/2 under a Type 0 parent) consume one code unit per glyph: typically 2 bytes via the Identity-H CMap, sometimes variable. layoutBytes is the unified iterator everything downstream uses.

Embedded outlines are pulled from whichever of these is present:

/FontFile → Type 1 (PostScript)
/FontFile2 → TrueType
/FontFile3 → CFF (Type1C or CIDFontType0C)

Order tried matches what real fonts actually carry; falls back to the host system font (via baseFont) when no outlines are available.

Types

Companion

object Companion

Properties

baseFont

val baseFont: String

fontSpec

val fontSpec: FontSpec

Platform-neutral substitute-font descriptor, derived from baseFont, for canvases that render non-embedded fonts through a host typeface. Centralises the family/style choice the render backends used to each make inline.

hasEmbeddedOutlines

val hasEmbeddedOutlines: Boolean

isComposite

val isComposite: Boolean

isVertical

val isVertical: Boolean

True when this font writes top to bottom: a Type 0 font whose CMap has writing mode 1, such as Identity-V (ISO 32000-1, 9.7.4.3 and 9.7.5.3). Each glyph then moves the pen down by its verticalMetrics, not right by its width.

subtype

val subtype: String

unitsPerEm

val unitsPerEm: Int?

The units per em of this font's outlines, or null without embedded outlines. A TrueType font reports its own. CFF and Type 1 outlines are already mapped through the program's FontMatrix into glyph space, where an em is 1000 units (ISO 32000-1, 9.2.4), so they report 1000.

Functions

decode

fun decode(bytes: ByteArray): String

Decode show-text bytes (from a Tj / TJ operand) to unicode text.

embeddedAdvanceWidth

fun embeddedAdvanceWidth(byteCode: Int): Int?

True iff the underlying embedded font has its own advance metrics.

forEachGlyphAdvance

fun forEachGlyphAdvance(bytes: ByteArray, action: (advanceWidth: Double, isWordSpace: Boolean) -> Unit)

Invoke action once per glyph with its advance width (1/1000 em) and word-space flag, WITHOUT resolving any glyph outline or allocating a TextGlyph list. The fast path for advance/measurement (text positioning, width sums) where glyph shapes aren't needed. The renderer's advance calculation, text extraction, and redaction layout all use it.

glyphIdForByte

fun glyphIdForByte(byteCode: Int): Int

Glyph id for a single byte code in a simple font. Returns 0 for composite fonts (their glyph IDs come from CIDs, not byte codes).

layoutBytes

fun layoutBytes(bytes: ByteArray, resolveOutlines: Boolean = true): List<TextGlyph>

Walk bytes one glyph at a time, dispatching to the right code-unit width (1 for simple fonts, usually 2 for Identity-H composites).

outlineForByte

fun outlineForByte(code: Int): KitePath?

Per-byte outline lookup. Kept for backward compat with callers that pre-date the layoutBytes iterator; layoutBytes is the right path for any new code so composite Type 0 fonts work correctly.

verticalMetrics

fun verticalMetrics(bytes: ByteArray): List<PdfVerticalMetrics>?

The vertical metrics of each glyph in bytes, in the order layoutBytes lays them out, or null when this font is not isVertical. ISO 32000-1, 9.7.4.3 reads them from the CIDFont's /W2 array, else from /DW2, whose default is [880 -1000].

widthOf

fun widthOf(byteCode: Int): Int

Width (1/1000 em) for a single byte code in a simple font. Composite use layoutBytes.