korge-core/korlibs.image.font/BaseTtfFont

BaseTtfFont

abstract class BaseTtfFont(s: FastByteArrayInputStream, extName: String? = null, onlyReadMetadata: Boolean = false, enableLigatures: Boolean = true) : VectorFont, Extra

Inheritors

TtfFont

WoffFont

Constructors

BaseTtfFont

constructor(d: ByteArray, extName: String? = null, onlyReadMetadata: Boolean = false, enableLigatures: Boolean = true)

constructor(s: FastByteArrayInputStream, extName: String? = null, onlyReadMetadata: Boolean = false, enableLigatures: Boolean = true)

Types

BitmapGlyphInfo

data class BitmapGlyphInfo(val glyphID: Int, val imageFormat: Int = 0, val offset: Int = 0, val size: Int = 0, val info: BaseTtfFont.ColorBitmapInfo, var height: Int = 0, var width: Int = 0, var horiBearingX: Int = 0, var horiBearingY: Int = 0, var horiAdvance: Int = 0, var vertBearingX: Int = 0, var vertBearingY: Int = 0, var vertAdvance: Int = 0)

CFFGlyph

inner class CFFGlyph(val index: Int, val xMin: Int, val yMin: Int, val xMax: Int, val yMax: Int, val advanceWidth: Int, val path: BaseTtfFont.GlyphGraphicsPath) : BaseTtfFont.Glyph

Clip

data class Clip(val startGlyphID: Int, val endGlyphID: Int, val clipBoxOffset: Int)

ColorBitmapInfo

data class ColorBitmapInfo(val indexSubTableArrayOffset: Int = 0, val indexTablesSize: Int = 0, val numberofIndexSubTables: Int = 0, val colorRef: Int = 0, val hori: BaseTtfFont.SbitLineMetrics = SbitLineMetrics(), val vert: BaseTtfFont.SbitLineMetrics = SbitLineMetrics(), val startGlyphIndex: Int = 0, val endGlyphIndex: Int = 0, val ppemX: Int = 0, val ppemY: Int = 0, val bitDepth: Int = 0, val flags: Int = 0)

ColorLine

data class ColorLine(val cycle: CycleMethod, val stops: List<BaseTtfFont.ColorStop>)

ColorStop

class ColorStop(var stopOffset: Double, var paletteIndex: Int, var alpha: Double)

ColrGlyphInfo

interface ColrGlyphInfo

ColrGlyphInfoV0

inner class ColrGlyphInfoV0(val glyphID: Int, val firstLayerIndex: Int, val numLayers: Int) : BaseTtfFont.ColrGlyphInfo

ColrGlyphInfoV1

inner class ColrGlyphInfoV1(val glyphID: Int, val paint: Int) : BaseTtfFont.ColrGlyphInfo

ColrLayerInfo

inner class ColrLayerInfo(val glyphID: Int, val paletteIndex: Int)

COLRv1

class COLRv1(var layerList: IntArray = intArrayOf(), var s: FastByteArrayInputStream = FastByteArrayInputStream(byteArrayOf()), var sBaseOffset: FastByteArrayInputStream = FastByteArrayInputStream(byteArrayOf()), var sLayerOffset: FastByteArrayInputStream = FastByteArrayInputStream(byteArrayOf()), var sClipOffset: FastByteArrayInputStream? = null)

Colrv1Paint

enum Colrv1Paint : Enum<BaseTtfFont.Colrv1Paint>

Companion

object Companion

CompositeGlyph

inner class CompositeGlyph(val index: Int, val xMin: Int, val yMin: Int, val xMax: Int, val yMax: Int, val refs: List<BaseTtfFont.GlyphReference>, val advanceWidth: Int) : BaseTtfFont.Glyph

Contour

data class Contour(var x: Int = 0, var y: Int = 0, var onCurve: Boolean = false)

Glyph

abstract inner class Glyph(val index: Int, val xMin: Int, val yMin: Int, val xMax: Int, val yMax: Int, val advanceWidth: Int)

GlyphGraphicsPath

data class GlyphGraphicsPath(val glpyhIndex: Int, val path: VectorPath) : IVectorPath

GlyphReference

data class GlyphReference(val glyph: BaseTtfFont.Glyph, val x: Int, val y: Int, val scaleX: Float, val scale01: Float, val scale10: Float, val scaleY: Float)

HorMetric

data class HorMetric(val advanceWidth: Int, val lsb: Int)

NameId

enum NameId : Enum<BaseTtfFont.NameId>

NameIds

enum NameIds : Enum<BaseTtfFont.NameIds>

NameInfo

data class NameInfo(val offset: Int, val length: Int, val charset: Charset)

NamesInfo

class NamesInfo

SbitLineMetrics

data class SbitLineMetrics(val ascender: Int = 0, val descender: Int = 0, val widthMax: Int = 0, val caretSlopeNumerator: Int = 0, val caretSlopeDenominator: Int = 0, val caretOffset: Int = 0, val minOriginSB: Int = 0, val minAdvanceSB: Int = 0, val maxBeforeBL: Int = 0, val minAfterBL: Int = 0, val pad1: Int = 0, val pad2: Int = 0)

SimpleGlyph

inner class SimpleGlyph(val index: Int, val xMin: Int, val yMin: Int, val xMax: Int, val yMax: Int, val contoursIndices: IntArray, val flags: IntArray, val xPos: IntArray, val yPos: IntArray, val advanceWidth: Int, val dummy: Boolean = false) : BaseTtfFont.Glyph

SubstitutionInfo

class SubstitutionInfo(val maxSequence: Int, val map: Map<WString, IntArray>)

Table

data class Table(val id: String, val checksum: Int, val offset: Int, val length: Int)

Properties

_cff

var _cff: TtfCIDFont.CFF.CFFResult?

advanceWidthMax

var advanceWidthMax: Int

ascender

var ascender: Int

bitmapGlyphInfos

var bitmapGlyphInfos: LinkedHashMap<Int, BaseTtfFont.BitmapGlyphInfo>

caretOffset

var caretOffset: Int

caretSlopeRise

var caretSlopeRise: Int

caretSlopeRun

var caretSlopeRun: Int

characterMaps

val characterMaps: LinkedHashMap<Int, Int>

characterMapsReverse

val characterMapsReverse: LinkedHashMap<Int, Int>

descender

var descender: Int

extra

open override var extra: ExtraType

fontMetrics1px

lateinit var fontMetrics1px: FontMetrics

glyphSubstitution

val glyphSubstitution: IntIntMap

GlyphID -> GlyphID

isOpenType

var isOpenType: Boolean

lazyBitmap

val Font.lazyBitmap: BitmapFont

Gets a BitmapFont from the font, that is going to be computed lazily as glyphs are required.

val VectorFont.lazyBitmap: LazyBitmapFont

Returns, creates and caches a LazyBitmapFont instance from the VectorFont that will generate and cache glyphs as required.

lazyBitmapSDF

val VectorFont.lazyBitmapSDF: LazyBitmapFont

lineGap

var lineGap: Int

maxComponentDepth

var maxComponentDepth: Int

maxComponentElements

var maxComponentElements: Int

maxCompositeContours

var maxCompositeContours: Int

maxCompositePoints

var maxCompositePoints: Int

maxContours

var maxContours: Int

maxFunctionDefs

var maxFunctionDefs: Int

maxInstructionDefs

var maxInstructionDefs: Int

maxPoints

var maxPoints: Int

maxSizeOfInstructions

var maxSizeOfInstructions: Int

maxStackElements

var maxStackElements: Int

maxStorage

var maxStorage: Int

maxTwilightPoints

var maxTwilightPoints: Int

maxZones

var maxZones: Int

metricDataFormat

var metricDataFormat: Int

minLeftSideBearing

var minLeftSideBearing: Int

minRightSideBearing

var minRightSideBearing: Int

name

open override val name: String

numberOfHMetrics

var numberOfHMetrics: Int

numGlyphs

var numGlyphs: Int

palettes

var palettes: List<Palette>

substitutionsCodePoints

val substitutionsCodePoints: IntMap<BaseTtfFont.SubstitutionInfo>

ttfCompleteName

val ttfCompleteName: String

ttfName

val ttfName: String

unitsPerEm

var unitsPerEm: Int

xMaxExtent

var xMaxExtent: Int

Functions

asFallbackOf

fun VectorFont.asFallbackOf(first: VectorFont): VectorFontList

When getting glyphs, it first tries to resolve with first, then this this

doInit

fun doInit()

drawText

fun <T> Font.drawText(ctx: Context2d?, size: Double, text: T, paint: Paint?, pos: Point = Point.ZERO, fill: Boolean = true, renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, align: TextAlignment = TextAlignment.BASELINE_LEFT, outMetrics: TextMetricsResult? = null, fillStyle: Paint? = null, stroke: Stroke? = null, textRangeStart: Int = 0, textRangeEnd: Int = Int.MAX_VALUE, placed: TextRendererActions.(codePoint: Int, Point, size: Double, metrics: GlyphMetrics, fmetrics: FontMetrics, transform: Matrix) -> Unit? = null): TextMetricsResult?

get

operator fun get(codePoint: WChar): BaseTtfFont.Glyph?

operator fun get(char: Char): BaseTtfFont.Glyph?

operator fun get(codePoint: Int): BaseTtfFont.Glyph?

open suspend override fun get(): Font

getAllBytes

fun getAllBytes(): ByteArray

getAllBytesUnsafe

fun getAllBytesUnsafe(): ByteArray

getAllGlyphs

fun getAllGlyphs(cache: Boolean = false): List<BaseTtfFont.Glyph>

getCharIndexFromChar

fun getCharIndexFromChar(char: Char): Int?

getCharIndexFromCodePoint

fun getCharIndexFromCodePoint(codePoint: Int): Int?

getCharIndexFromWChar

fun getCharIndexFromWChar(char: WChar): Int?

getCodePointFromCharIndex

fun getCodePointFromCharIndex(charIndex: Int): Int?

getCodePointFromCharIndexOrElse

fun getCodePointFromCharIndexOrElse(charIndex: Int, default: Int = -1): Int

getFontMetrics

open override fun getFontMetrics(size: Double, metrics: FontMetrics): FontMetrics

getGlyphByChar

fun getGlyphByChar(char: Char, cache: Boolean = true): BaseTtfFont.Glyph?

getGlyphByCodePoint

fun getGlyphByCodePoint(codePoint: Int, cache: Boolean = true): BaseTtfFont.Glyph?

getGlyphByIndex

fun getGlyphByIndex(index: Int, cache: Boolean = true, codePoint: Int = -1): BaseTtfFont.Glyph?

getGlyphByReader

fun getGlyphByReader(reader: WStringReader?, codePoint: Int, cache: Boolean = true): BaseTtfFont.Glyph?

getGlyphByWChar

fun getGlyphByWChar(char: WChar, cache: Boolean = true): BaseTtfFont.Glyph?

getGlyphMetrics

open override fun getGlyphMetrics(size: Double, codePoint: Int, metrics: GlyphMetrics, reader: WStringReader?): GlyphMetrics

getGlyphPath

open override fun getGlyphPath(size: Double, codePoint: Int, path: GlyphPath, reader: WStringReader?): GlyphPath?

getGlyphsByReader

fun getGlyphsByReader(reader: WStringReader, out: MutableList<BaseTtfFont.Glyph> = arrayListOf()): List<BaseTtfFont.Glyph>

getKerning

open override fun getKerning(size: Double, leftCodePoint: Int, rightCodePoint: Int): Double

getName

fun getName(nameId: BaseTtfFont.NameId): String?

fun getName(nameId: Int): String?

getOrNull

open override fun getOrNull(): Font

getTable

abstract fun getTable(name: String): BaseTtfFont.Table?

getTableNames

abstract fun getTableNames(): Set<String>

getTextBounds

fun <T> Font.getTextBounds(size: Double, text: T, out: TextMetrics = TextMetrics(), renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, align: TextAlignment = TextAlignment.TOP_LEFT): TextMetrics

getTextBoundsWithGlyphs

fun <T> Font.getTextBoundsWithGlyphs(size: Double, text: T, renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, align: TextAlignment = TextAlignment.BASELINE_LEFT): TextMetricsResult

readAffine2x3

fun FastByteArrayInputStream.readAffine2x3(isVar: Boolean): Matrix

readArrayOf16

inline fun <T> FastByteArrayInputStream.readArrayOf16(block: FastByteArrayInputStream.(index: Int) -> T): Array<T>

readArrayOf32

inline fun <T> FastByteArrayInputStream.readArrayOf32(block: FastByteArrayInputStream.(index: Int) -> T): Array<T>

readBaseGlyphPaintRecord

fun FastByteArrayInputStream.readBaseGlyphPaintRecord()

readClipBox

fun FastByteArrayInputStream.readClipBox(doVar: Boolean = false): Rectangle

readColorLine

fun FastByteArrayInputStream.readColorLine(): BaseTtfFont.ColorLine

readColorStop

fun FastByteArrayInputStream.readColorStop(out: BaseTtfFont.ColorStop = ColorStop(0.0, 0, 0.0)): BaseTtfFont.ColorStop

readCoverage

fun FastByteArrayInputStream.readCoverage(hintedCount: Int = -1): IntArray

readFWORD

fun FastByteArrayInputStream.readFWORD(): Int

readOffset16

fun FastByteArrayInputStream.readOffset16(): Int

readOffset24

fun FastByteArrayInputStream.readOffset24(): Int

readOffset32

fun FastByteArrayInputStream.readOffset32(): Int

readUFWORD

fun FastByteArrayInputStream.readUFWORD(): Int

readVarIdxBase

fun FastByteArrayInputStream.readVarIdxBase(): Int

registerTemporarily

inline suspend fun <T> Font.registerTemporarily(name: String = this.name, block: () -> T): T

inline fun <T> Font.registerTemporarily(registry: DefaultFontRegistry, name: String = this.name, block: () -> T): T

renderGlyph

open override fun renderGlyph(ctx: Context2d, size: Double, codePoint: Int, pos: Point, fill: Boolean?, metrics: GlyphMetrics, reader: WStringReader?, beforeDraw: () -> Unit?): Boolean

renderGlyphToBitmap

fun Font.renderGlyphToBitmap(size: Double, codePoint: Int, paint: Paint = DefaultPaint, fill: Boolean = true, effect: BitmapEffect? = null, border: Int = 1, nativeRendering: Boolean = true, reader: WStringReader? = null): TextToBitmapResult

renderTextToBitmap

fun <T> Font.renderTextToBitmap(size: Double, text: T, paint: Paint = DefaultPaint, background: Paint = NonePaint, fill: Boolean = true, border: Int = 0, renderer: TextRenderer<T> = DefaultStringTextRenderer as TextRenderer<T>, returnGlyphs: Boolean = true, nativeRendering: Boolean = true, drawBorder: Boolean = false): TextToBitmapResult

toBitmapFont

inline fun Font.toBitmapFont(fontSize: Number, chars: CharacterSet = CharacterSet.LATIN_ALL, fontName: String = this.name, paint: Paint = Colors.WHITE, mipmaps: Boolean = true, effect: BitmapEffect? = null): BitmapFont

toLazyBitmapFont

fun VectorFont.toLazyBitmapFont(fontSize: Double, distanceField: String? = null): LazyBitmapFont

toString

open override fun toString(): String

withFallback

fun VectorFont.withFallback(vararg other: VectorFont?): VectorFontList

When getting glyphs, it first tries to resolve with this, then in order other