Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.2

0.19.2 / src / font.lucb

## UI typography owns a native face and a bounded cache of grayscale text runs.
## Font copies borrow; widgets clone the shared reference and release it on close.
from luce_fonts import fonts
from luce_gpu import gpu
import interop
from luce_std import math
import memory
import ownership

struct CachedRun:
    var text: interop.Owned[str]?
    var bitmap: fonts.Bitmap
    var scale: f64
    var used: u64

    func close():
        if let text = self.text:
            text.release()
        self.bitmap.close()
        self = CachedRun()

struct FontState:
    var face: fonts.Face
    var runs: CachedRun[]
    var clock: u64
    var bytes: usize

    func close():
        for index in 0..<self.runs.length:
            self.runs[index].close()
        if self.runs.length > 0:
            free(self.runs) in memory.heap
        var empty: CachedRun[]
        self.runs = empty
        self.face.close()

    pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        for run in self.runs:
            if let text = run.text:
                text.trace(visit, context)

    func raster(text: str, scale: f64) -> fonts.Bitmap!:
        self.clock += 1
        var oldest: usize = 0
        for index in 0..<self.runs.length:
            let run = self.runs[index]
            if let cached = run.text:
                if run.scale == scale and cached.value == text:
                    self.runs[index].used = self.clock
                    return run.bitmap
            if run.used < self.runs[oldest].used:
                oldest = index
        let bitmap = try self.face.rasterize(text, scale)
        errdefer close_bitmap(bitmap)
        let copied = try interop.copy_text(text)
        errdefer copied.release()
        # Evict least-recently-used runs before accepting another raster. The
        # image limit and entry limit bound both pixel storage and string owners.
        while self.bytes + bitmap.pixels.length > 16777216:
            self.bytes -= self.runs[oldest].bitmap.pixels.length
            self.runs[oldest].close()
            var found = false
            for index in 0..<self.runs.length:
                if self.runs[index].text != none:
                    if not found or self.runs[index].used < self.runs[oldest].used:
                        oldest = index
                        found = true
        self.bytes -= self.runs[oldest].bitmap.pixels.length
        self.runs[oldest].close()
        self.runs[oldest] = CachedRun(copied, bitmap, scale, self.clock)
        self.bytes += bitmap.pixels.length
        return bitmap

func close_bitmap(bitmap: fonts.Bitmap):
    var owned = bitmap
    owned.close()

let font_state_type: interop.Type[FontState] = interop.Type[FontState]("UI font cache", FontState.close, FontState.trace, closeable = true, main_thread = true)

## The shared UI default, in logical points.
pub let default_font_size: f64 = 12.0

## An installed monospace font. Size is measured in logical points; rasterization
## follows the target's backing scale, so Retina text retains its intended size.
## Use one shared Font across controls to keep typography consistent.
pub struct Font:
    var state: interop.Reference[FontState]

    pub func init(size: f64 = default_font_size, family: str = "") -> !:
        var reservation = try interop.Reservation[FontState](font_state_type)
        errdefer reservation.cancel()
        var face = try fonts.Face(size, family)
        errdefer face.close()
        let runs = try new CachedRun[512] in memory.heap
        errdefer free(runs) in memory.heap
        let storage = try new FontState(face = face, runs = runs) in memory.heap
        self.state = reservation.publish(storage, memory.heap)

    ## Replace the shared face only after loading succeeds. Controls retain the
    ## Font object, so a settings reload updates all of them together.
    pub func configure(size: f64, family: str = "") -> !:
        let replacement = try Font(size, family)
        let previous_state = self.state
        self.state = replacement.state
        previous_state.release()

    pub func size() -> f64:
        return self.state.value().face.size

    pub func advance() -> f64:
        return self.state.value().face.advance

    pub func height() -> f64:
        let face = self.state.value().face
        return face.ascent + face.descent

    pub func line_height() -> f64:
        return math.ceil(self.height() + self.size() / 3.0)

    pub func measure(text: str) -> f64!:
        return try self.state.value().face.measure(text)

    ## The monospace cells `text` takes: two per wide East Asian scalar, none per
    ## combining mark, one for the rest. Fails when `text` is not UTF-8.
    pub func cells(text: str) -> i64!:
        return (i64)(try fonts.text_cells(text))

    ## Internal rendering entry: cache-owned pixels are copied into the frame.
    ## The application never sees native fonts, raster storage or backend objects.
    pub func draw(target: interop.View[gpu.RenderTarget], text: str, x: f64, y: f64, color: gpu.Color) -> !:
        _ = try self.measure(text)
        if text.length == 0:
            return
        let destination = try target.get()
        let size = try destination.size()
        if size.width <= 0.0 or size.height <= 0.0:
            return
        let scale = math.clamp(size.scale, 0.5, 4.0)
        let bitmap = try self.state.value().raster(text, scale)
        let rectangle = gpu.Rect(x - bitmap.padding, y - bitmap.padding,
                                 (f64)bitmap.width / scale, (f64)bitmap.height / scale)
        try destination.mask(bitmap.pixels, bitmap.width, bitmap.height, rectangle, color)

    pub func close():
        self.state.release()

    pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        self.state.trace(visit, context)

pub let font_type: interop.Type[Font] = interop.Type[Font]("Font", Font.close, Font.trace, closeable = true, main_thread = true)

pub func selected_font(font: interop.Reference[Font]?) -> interop.Reference[Font]!:
    if let existing = font:
        return existing.clone()
    return try interop.Reference[Font].adopt(new Font() in memory.heap, font_type, memory.heap)