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 "")