Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-fonts

Source of release 0.7.1

0.7.1 / src / fonts / linux / native.lucb

#==============================================================================================
#
#   native - The Linux (Cairo/FreeType) font backend
#
#   DESCRIPTION:
#       Cairo resolves fontconfig's installed monospace family and rasterizes through
#       FreeType. Its A8 row stride is copied into the portable tightly packed image.
#
#==============================================================================================

extern struct CairoFontMetrics:
    ascent: f64
    descent: f64
    height: f64
    advance_x: f64
    advance_y: f64

extern struct CairoTextMetrics:
    x: f64
    y: f64
    width: f64
    height: f64
    advance_x: f64
    advance_y: f64

extern func dlopen(file: c.str, mode: i32) -> void*?
extern func dlsym(handle: void*, name: c.str) -> void*?

## Cairo's functions, loaded on first use from the runtime library every
## desktop has (libcairo.so.2): building needs no development package.
struct CairoApi:
    var image_surface_create: func(i32, i32, i32) -> void*
    var surface_status: func(void*) -> i32
    var surface_destroy: func(void*) -> unit
    var surface_flush: func(void*) -> unit
    var image_surface_get_data: func(void*) -> u8*
    var image_surface_get_stride: func(void*) -> i32
    var create: func(void*) -> void*
    var destroy: func(void*) -> unit
    var status: func(void*) -> i32
    var select_font_face: func(void*, c.str, i32, i32) -> unit
    var set_font_size: func(void*, f64) -> unit
    var font_extents: func(void*, CairoFontMetrics*) -> unit
    var text_extents: func(void*, c.str, CairoTextMetrics*) -> unit
    var get_scaled_font: func(void*) -> void*
    var scaled_font_reference: func(void*) -> void*
    var scaled_font_destroy: func(void*) -> unit
    var scaled_font_get_font_face: func(void*) -> void*
    var set_font_face: func(void*, void*) -> unit
    var set_source_rgba: func(void*, f64, f64, f64, f64) -> unit
    var move_to: func(void*, f64, f64) -> unit
    var show_text: func(void*, c.str) -> unit
    var font_options_create: func() -> void*
    var font_options_destroy: func(void*) -> unit
    var font_options_set_antialias: func(void*, i32) -> unit
    var font_options_set_hint_metrics: func(void*, i32) -> unit
    var set_font_options: func(void*, void*) -> unit
    var get_font_face: func(void*) -> void*

var loaded_cairo: CairoApi? = none

func cairo() -> CairoApi!:
    if let api = loaded_cairo:
        return api
    # RTLD_NOW: every symbol is resolved here, not at a later call.
    let library = dlopen("libcairo.so.2", 2) else error(failed, "Cairo (libcairo.so.2) is not installed")
    let api = CairoApi(
        image_surface_create = (func(i32, i32, i32) -> void*)(try cairo_symbol(library, "cairo_image_surface_create")),
        surface_status = (func(void*) -> i32)(try cairo_symbol(library, "cairo_surface_status")),
        surface_destroy = (func(void*) -> unit)(try cairo_symbol(library, "cairo_surface_destroy")),
        surface_flush = (func(void*) -> unit)(try cairo_symbol(library, "cairo_surface_flush")),
        image_surface_get_data = (func(void*) -> u8*)(try cairo_symbol(library, "cairo_image_surface_get_data")),
        image_surface_get_stride = (func(void*) -> i32)(try cairo_symbol(library, "cairo_image_surface_get_stride")),
        create = (func(void*) -> void*)(try cairo_symbol(library, "cairo_create")),
        destroy = (func(void*) -> unit)(try cairo_symbol(library, "cairo_destroy")),
        status = (func(void*) -> i32)(try cairo_symbol(library, "cairo_status")),
        select_font_face = (func(void*, c.str, i32, i32) -> unit)(try cairo_symbol(library, "cairo_select_font_face")),
        set_font_size = (func(void*, f64) -> unit)(try cairo_symbol(library, "cairo_set_font_size")),
        font_extents = (func(void*, CairoFontMetrics*) -> unit)(try cairo_symbol(library, "cairo_font_extents")),
        text_extents = (func(void*, c.str, CairoTextMetrics*) -> unit)(try cairo_symbol(library, "cairo_text_extents")),
        get_scaled_font = (func(void*) -> void*)(try cairo_symbol(library, "cairo_get_scaled_font")),
        scaled_font_reference = (func(void*) -> void*)(try cairo_symbol(library, "cairo_scaled_font_reference")),
        scaled_font_destroy = (func(void*) -> unit)(try cairo_symbol(library, "cairo_scaled_font_destroy")),
        scaled_font_get_font_face = (func(void*) -> void*)(try cairo_symbol(library, "cairo_scaled_font_get_font_face")),
        set_font_face = (func(void*, void*) -> unit)(try cairo_symbol(library, "cairo_set_font_face")),
        set_source_rgba = (func(void*, f64, f64, f64, f64) -> unit)(try cairo_symbol(library, "cairo_set_source_rgba")),
        move_to = (func(void*, f64, f64) -> unit)(try cairo_symbol(library, "cairo_move_to")),
        show_text = (func(void*, c.str) -> unit)(try cairo_symbol(library, "cairo_show_text")),
        font_options_create = (func() -> void*)(try cairo_symbol(library, "cairo_font_options_create")),
        font_options_destroy = (func(void*) -> unit)(try cairo_symbol(library, "cairo_font_options_destroy")),
        font_options_set_antialias = (func(void*, i32) -> unit)(try cairo_symbol(library, "cairo_font_options_set_antialias")),
        font_options_set_hint_metrics = (func(void*, i32) -> unit)(try cairo_symbol(library, "cairo_font_options_set_hint_metrics")),
        set_font_options = (func(void*, void*) -> unit)(try cairo_symbol(library, "cairo_set_font_options")),
        get_font_face = (func(void*) -> void*)(try cairo_symbol(library, "cairo_get_font_face")))
    loaded_cairo = api
    return api

func cairo_symbol(library: void*, name: c.str) -> void*!:
    return dlsym(library, name) else error(failed, "the installed Cairo lacks a function luce-fonts needs")

## A face's Cairo objects released; they exist only once Cairo is loaded.
func linux_release_font(font: void*):
    if let api = loaded_cairo:
        api.scaled_font_destroy(font)

func linux_release_context(context: void*):
    if let api = loaded_cairo:
        api.destroy(context)

func linux_options(api: CairoApi, context: void*):
    let options = api.font_options_create()
    defer api.font_options_destroy(options)
    api.font_options_set_antialias(options, 2)
    api.font_options_set_hint_metrics(options, 1)
    api.set_font_options(context, options)

func linux_face(size: f64, family: str) -> NativeFace!:
    let api = try cairo()
    let name = try family_bytes("monospace" if family.length == 0 else family)
    defer free(name)
    let surface = api.image_surface_create(2, 1, 1)
    defer api.surface_destroy(surface)
    let context = api.create(surface)
    defer api.destroy(context)
    linux_options(api, context)
    api.select_font_face(context, (c.str)name.data, 0, 0)
    api.set_font_size(context, size)
    var metrics: CairoFontMetrics
    api.font_extents(context, &metrics)
    var narrow: CairoTextMetrics
    var wide: CairoTextMetrics
    api.text_extents(context, "i", &narrow)
    api.text_extents(context, "W", &wide)
    if api.status(context) != 0 or wide.advance_x <= 0.0 or math.abs(narrow.advance_x - wide.advance_x) > 0.01:
        error(failed, "the requested font must be an available monospace face")
    let font = api.scaled_font_reference(api.get_scaled_font(context))
    return NativeFace(font, none, wide.advance_x, metrics.ascent, metrics.descent)

func linux_raster(face: Face, text: str, scale: f64, bitmap: Bitmap*) -> !:
    let api = try cairo()
    let font = face.native else error(failed, "the font is closed")
    let surface = api.image_surface_create(2, (i32)bitmap.width, (i32)bitmap.height)
    defer api.surface_destroy(surface)
    if api.surface_status(surface) != 0:
        error(failed, "could not allocate font raster storage")
    let context = api.create(surface)
    defer api.destroy(context)
    linux_options(api, context)
    api.set_font_face(context, api.scaled_font_get_font_face(font))
    api.set_font_size(context, face.size * scale)
    api.set_source_rgba(context, 1.0, 1.0, 1.0, 1.0)
    var offset: usize = 0
    var column: usize = 0
    while offset < text.length:
        let decoded = utf8.decode(text.bytes, offset) else trap("validated text changed")
        var scalar: u8[5]
        for byte in 0..<decoded.width:
            scalar[byte] = text.bytes[offset + byte]
        scalar[decoded.width] = 0
        let width = cells((u32)decoded.scalar)
        var glyph = 0.0
        if width != 1:
            var extents: CairoTextMetrics
            api.text_extents(context, (c.str)&scalar[0], &extents)
            glyph = extents.advance_x / scale
        let x = (f64)column * face.advance + glyph_offset(width, glyph, face.advance)
        api.move_to(context, 2.0 + x * scale, 2.0 + face.ascent * scale)
        api.show_text(context, (c.str)&scalar[0])
        offset += decoded.width
        column += (usize)width
    if api.status(context) != 0:
        error(failed, "could not rasterize the font text")
    api.surface_flush(surface)
    let source = api.image_surface_get_data(surface)
    let stride = (usize)api.image_surface_get_stride(surface)
    for row in 0..<(usize)bitmap.height:
        memory.copy(bitmap.pixels[row * (usize)bitmap.width..], u8[](source + row * stride, (usize)bitmap.width), (usize)bitmap.width)

# mark: Proportional type ======================================================================

func linux_type(family: str, style: str, size: f64) -> LoadedType!:
    let api = try cairo()
    let name = try family_bytes(family)
    defer free(name)
    let surface = api.image_surface_create(2, 1, 1)
    defer api.surface_destroy(surface)
    let context = api.create(surface)
    errdefer api.destroy(context)
    linux_options(api, context)
    let italic = holds(style, "italic") or holds(style, "oblique")
    api.select_font_face(context, (c.str)name.data, 1 if italic else 0, 1 if holds(style, "bold") else 0)
    api.set_font_size(context, size)
    var metrics: CairoFontMetrics
    api.font_extents(context, &metrics)
    if api.status(context) != 0:
        error(failed, "could not load the font")
    return LoadedType(native = context, auxiliary = none, ascent = metrics.ascent, descent = metrics.descent,
                      gap = math.max(0.0, metrics.height - metrics.ascent - metrics.descent))

func linux_measure_run(face: const TypeFace*, text: str) -> f64!:
    let api = try cairo()
    let context = face.native else error(failed, "the face is closed")
    let bytes = try family_bytes(text)
    defer free(bytes)
    var extents: CairoTextMetrics
    api.text_extents(context, (c.str)bytes.data, &extents)
    return extents.advance_x

func linux_draw_run(face: const TypeFace*, text: str, x: f64, baseline: f64, bitmap: Bitmap*) -> !:
    let api = try cairo()
    let source_context = face.native else error(failed, "the face is closed")
    let bytes = try family_bytes(text)
    defer free(bytes)
    let surface = api.image_surface_create(2, (i32)bitmap.width, (i32)bitmap.height)
    defer api.surface_destroy(surface)
    if api.surface_status(surface) != 0:
        error(failed, "could not allocate font raster storage")
    let context = api.create(surface)
    defer api.destroy(context)
    linux_options(api, context)
    api.set_font_face(context, api.get_font_face(source_context))
    api.set_font_size(context, face.size)
    api.set_source_rgba(context, 1.0, 1.0, 1.0, 1.0)
    api.move_to(context, x, baseline)
    api.show_text(context, (c.str)bytes.data)
    api.surface_flush(surface)
    let source = api.image_surface_get_data(surface)
    let stride = (usize)api.image_surface_get_stride(surface)
    # Over what is there: the larger coverage wins.
    for row in 0..<(usize)bitmap.height:
        for column in 0..<(usize)bitmap.width:
            let value = source[row * stride + column]
            let at = row * (usize)bitmap.width + column
            if value > bitmap.pixels[at]:
                bitmap.pixels[at] = value

# mark: Families and styles ==================================================================

## FcFontSet: the matched patterns.
extern struct FcFontSet:
    count: i32
    size: i32
    fonts: void**

## Fontconfig's functions for listing, loaded on first use from the runtime
## library every desktop has (libfontconfig.so.1), as Cairo's are.
struct FontconfigApi:
    var init_load: func() -> void*?
    var pattern_create: func() -> void*
    var pattern_destroy: func(void*) -> unit
    var pattern_add_string: func(void*, c.str, c.str) -> i32
    var pattern_get_string: func(void*, c.str, i32, c.char**) -> i32
    var object_set_create: func() -> void*
    var object_set_add: func(void*, c.str) -> i32
    var object_set_destroy: func(void*) -> unit
    var font_list: func(void*?, void*, void*) -> FcFontSet*?
    var font_set_destroy: func(FcFontSet*) -> unit

var loaded_fontconfig: FontconfigApi? = none

func fontconfig() -> FontconfigApi!:
    if let api = loaded_fontconfig:
        return api
    let library = dlopen("libfontconfig.so.1", 2) else error(failed, "Fontconfig (libfontconfig.so.1) is not installed")
    let api = FontconfigApi(
        init_load = (func() -> void*?)(try cairo_symbol(library, "FcInitLoadConfigAndFonts")),
        pattern_create = (func() -> void*)(try cairo_symbol(library, "FcPatternCreate")),
        pattern_destroy = (func(void*) -> unit)(try cairo_symbol(library, "FcPatternDestroy")),
        pattern_add_string = (func(void*, c.str, c.str) -> i32)(try cairo_symbol(library, "FcPatternAddString")),
        pattern_get_string = (func(void*, c.str, i32, c.char**) -> i32)(try cairo_symbol(library, "FcPatternGetString")),
        object_set_create = (func() -> void*)(try cairo_symbol(library, "FcObjectSetCreate")),
        object_set_add = (func(void*, c.str) -> i32)(try cairo_symbol(library, "FcObjectSetAdd")),
        object_set_destroy = (func(void*) -> unit)(try cairo_symbol(library, "FcObjectSetDestroy")),
        font_list = (func(void*?, void*, void*) -> FcFontSet*?)(try cairo_symbol(library, "FcFontList")),
        font_set_destroy = (func(FcFontSet*) -> unit)(try cairo_symbol(library, "FcFontSetDestroy")))
    _ = api.init_load()
    loaded_fontconfig = api
    return api

## The installed families, from fontconfig; the three every desktop resolves
## when fontconfig is missing.
func linux_families(names: Names*) -> !:
    let api = fontconfig() catch failure:
        _ = failure
        for name in ["Sans", "Serif", "Monospace"]:
            try names.add(name)
        return
    try linux_list(api, "", "family", names)

## The styles `family` comes in, from fontconfig.
func linux_styles(family: str, names: Names*) -> !:
    let api = fontconfig() catch failure:
        _ = failure
        for name in ["Regular", "Bold", "Italic", "Bold Italic"]:
            try names.add(name)
        return
    try linux_list(api, family, "style", names)

## Every value of `property` among the fonts of `family` ("" for all fonts).
func linux_list(api: FontconfigApi, family: str, property: c.str, names: Names*) -> !:
    let pattern = api.pattern_create()
    defer api.pattern_destroy(pattern)
    if family.length > 0:
        let name = try family_bytes(family)
        defer free(name)
        _ = api.pattern_add_string(pattern, "family", (c.str)name.data)
    let wanted = api.object_set_create()
    defer api.object_set_destroy(wanted)
    _ = api.object_set_add(wanted, property)
    let found = api.font_list(none, pattern, wanted) else error(failed, "fontconfig could not list the fonts")
    defer api.font_set_destroy(found)
    for index in 0..<(usize)found.count:
        var value: c.char* = (c.char*)(void*)0
        # FcResultMatch is 0; the value is borrowed from the set.
        if api.pattern_get_string(found.fonts[index], property, 0, &value) == 0:
            try names.add(str((c.str)value) catch: recover "")