mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-10 04:27:45 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/font.c

790 lines
23 KiB
C
Raw Normal View History

initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
#include "font.h"
#include <stdlib.h>
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
#include <stdint.h>
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
#include <stdbool.h>
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
#include <wchar.h>
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
#include <math.h>
font: sync cairo's options with the FC pattern Configure cairo's 'options' with default values, then update the FontConfig pattern. Finally, update the cairo options after having retrieved the final FontConfig option.
2019-07-17 22:50:26 +02:00
#include <assert.h>
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
#include <threads.h>
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
#include <freetype/tttables.h>
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
#define LOG_MODULE "font"
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
#define LOG_ENABLE_DBG 0
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
#include "log.h"
refactor: break out stride calculation to new function
2019-08-18 17:59:43 +02:00
#include "stride.h"
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
#define min(x, y) ((x) < (y) ? (x) : (y))
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
static FT_Library ft_lib;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
static mtx_t ft_lock;
font: cache_size -> glyph_cache_size This makes it more clear it has nothing to do with the font cache.
2019-11-30 12:41:09 +01:00
static const size_t glyph_cache_size = 512;
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
font: cache loaded fonts globally Each font instance has a ref-counter. Whenever we want to instantiate a font that has already been loaded, we instead return the already-loaded instance, and bump the ref counter. When the last font instance is destroyed, it is also removed from the cache.
2019-11-01 20:40:42 +01:00
struct font_cache_entry {
uint64_t hash;
struct font *font;
};
static tll(struct font_cache_entry) font_cache = tll_init();
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
static void __attribute__((constructor))
init(void)
{
FcInit();
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
FT_Init_FreeType(&ft_lib);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
mtx_init(&ft_lock, mtx_plain);
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
}
static void __attribute__((destructor))
fini(void)
{
font: cache loaded fonts globally Each font instance has a ref-counter. Whenever we want to instantiate a font that has already been loaded, we instead return the already-loaded instance, and bump the ref counter. When the last font instance is destroyed, it is also removed from the cache.
2019-11-01 20:40:42 +01:00
while (tll_length(font_cache) > 0)
font: destructor: pop elements as we go Otherwise we'll end up free:ing the same font over and over again.
2019-11-30 12:39:18 +01:00
font_destroy(tll_pop_front(font_cache).font);
font: cache loaded fonts globally Each font instance has a ref-counter. Whenever we want to instantiate a font that has already been loaded, we instead return the already-loaded instance, and bump the ref counter. When the last font instance is destroyed, it is also removed from the cache.
2019-11-01 20:40:42 +01:00
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
mtx_destroy(&ft_lock);
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
FT_Done_FreeType(ft_lib);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
FcFini();
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
}
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
font: log freetype errors
2019-11-30 12:35:07 +01:00
static const char *
ft_error_string(FT_Error err)
{
#undef FTERRORS_H_
#undef __FTERRORS_H__
#define FT_ERRORDEF( e, v, s ) case e: return s;
#define FT_ERROR_START_LIST switch (err) {
#define FT_ERROR_END_LIST }
#include FT_ERRORS_H
return "unknown error";
}
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
static void
underline_strikeout_metrics(struct font *font)
{
FT_Face ft_face = font->face;
font: bug: bad multiplier when converting from 16.16 fixed float
2019-11-30 13:10:20 +01:00
double y_scale = ft_face->size->metrics.y_scale / 65536.;
font: underline/strikeout: use y-scale, not x-scale
2019-11-26 18:56:12 +01:00
double height = ft_face->size->metrics.height / 64.;
double descent = ft_face->size->metrics.descender / 64.;
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
font: underline/strikeout: use y-scale, not x-scale
2019-11-26 18:56:12 +01:00
LOG_DBG("ft: y-scale: %f, height: %f, descent: %f",
y_scale, height, descent);
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
render: fix underline/strikeout positioning There were two errors: * We subtracted half the line width instead of adding it to the baseline * We rounded the line positioning and thickness before the positioning calculation. In particular, rounding the thickness before using it to adjust the position was wrong. Now we round just before the pixman call.
2019-11-30 14:53:22 +01:00
font->underline.position = ft_face->underline_position * y_scale / 64.;
font->underline.thickness = ft_face->underline_thickness * y_scale / 64.;
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
if (font->underline.position == 0.) {
render: fix underline/strikeout positioning There were two errors: * We subtracted half the line width instead of adding it to the baseline * We rounded the line positioning and thickness before the positioning calculation. In particular, rounding the thickness before using it to adjust the position was wrong. Now we round just before the pixman call.
2019-11-30 14:53:22 +01:00
font->underline.position = descent / 2.;
font->underline.thickness = descent / 5.;
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
}
render: fix underline/strikeout positioning There were two errors: * We subtracted half the line width instead of adding it to the baseline * We rounded the line positioning and thickness before the positioning calculation. In particular, rounding the thickness before using it to adjust the position was wrong. Now we round just before the pixman call.
2019-11-30 14:53:22 +01:00
LOG_DBG("underline: pos=%f, thick=%f",
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
font->underline.position, font->underline.thickness);
TT_OS2 *os2 = FT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
if (os2 != NULL) {
render: fix underline/strikeout positioning There were two errors: * We subtracted half the line width instead of adding it to the baseline * We rounded the line positioning and thickness before the positioning calculation. In particular, rounding the thickness before using it to adjust the position was wrong. Now we round just before the pixman call.
2019-11-30 14:53:22 +01:00
font->strikeout.position = os2->yStrikeoutPosition * y_scale / 64.;
font->strikeout.thickness = os2->yStrikeoutSize * y_scale / 64.;
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
}
if (font->strikeout.position == 0.) {
render: fix underline/strikeout positioning There were two errors: * We subtracted half the line width instead of adding it to the baseline * We rounded the line positioning and thickness before the positioning calculation. In particular, rounding the thickness before using it to adjust the position was wrong. Now we round just before the pixman call.
2019-11-30 14:53:22 +01:00
font->strikeout.position = height / 2. + descent;
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
font->strikeout.thickness = font->underline.thickness;
}
render: fix underline/strikeout positioning There were two errors: * We subtracted half the line width instead of adding it to the baseline * We rounded the line positioning and thickness before the positioning calculation. In particular, rounding the thickness before using it to adjust the position was wrong. Now we round just before the pixman call.
2019-11-30 14:53:22 +01:00
LOG_DBG("strikeout: pos=%f, thick=%f",
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
font->strikeout.position, font->strikeout.thickness);
}
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
static bool
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
from_font_set(FcPattern *pattern, FcFontSet *fonts, int start_idx,
struct font *font, bool is_fallback)
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
{
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
memset(font, 0, sizeof(*font));
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
FcChar8 *face_file = NULL;
FcPattern *final_pattern = NULL;
int font_idx = -1;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
for (int i = start_idx; i < fonts->nfont; i++) {
FcPattern *pat = FcFontRenderPrepare(NULL, pattern, fonts->fonts[i]);
assert(pat != NULL);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
if (FcPatternGetString(pat, FC_FT_FACE, 0, &face_file) != FcResultMatch) {
if (FcPatternGetString(pat, FC_FILE, 0, &face_file) != FcResultMatch) {
FcPatternDestroy(pat);
continue;
}
}
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
final_pattern = pat;
font_idx = i;
break;
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
}
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
assert(font_idx != -1);
assert(final_pattern != NULL);
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
double dpi;
if (FcPatternGetDouble(final_pattern, FC_DPI, 0, &dpi) != FcResultMatch)
font: use DPI=75 if there's no DPI attribute from fontconfig This is the fontconfig default as well
2019-11-26 18:57:18 +01:00
dpi = 75;
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
double size;
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
if (FcPatternGetDouble(final_pattern, FC_SIZE, 0, &size) != FcResultMatch)
LOG_WARN("%s: failed to get size", face_file);
double pixel_size;
if (FcPatternGetDouble(final_pattern, FC_PIXEL_SIZE, 0, &pixel_size) != FcResultMatch) {
LOG_ERR("%s: failed to get pizel size", face_file);
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
FcPatternDestroy(final_pattern);
return false;
}
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
mtx_lock(&ft_lock);
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
FT_Face ft_face;
FT_Error ft_err = FT_New_Face(ft_lib, (const char *)face_file, 0, &ft_face);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
mtx_unlock(&ft_lock);
font: cleanup and return error when failing to load font file
2019-11-25 20:17:15 +01:00
if (ft_err != 0) {
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
LOG_ERR("%s: failed to create FreeType face", face_file);
font: cleanup and return error when failing to load font file
2019-11-25 20:17:15 +01:00
FcPatternDestroy(final_pattern);
return false;
}
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
if ((ft_err = FT_Set_Pixel_Sizes(ft_face, 0, pixel_size)) != 0) {
font: use FT_Set_Pixel_Sizes() instead of FT_Set_Char_Size() Since we're working with pixel sizes anyway...
2019-11-25 20:14:48 +01:00
LOG_WARN("%s: failed to set character size", face_file);
mtx_lock(&ft_lock);
FT_Done_Face(ft_face);
mtx_unlock(&ft_lock);
FcPatternDestroy(final_pattern);
return false;
}
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
FcBool scalable;
if (FcPatternGetBool(final_pattern, FC_SCALABLE, 0, &scalable) != FcResultMatch)
scalable = FcTrue;
FcBool outline;
if (FcPatternGetBool(final_pattern, FC_OUTLINE, 0, &outline) != FcResultMatch)
outline = FcTrue;
double pixel_fixup = 1.;
font: use pixelsizefixupfactor on regular bitmap fonts too, if set But if it isn't set, only estimate it if the font is a *scalable* non-outline (bitmap) font.
2019-11-28 21:32:28 +01:00
if (FcPatternGetDouble(final_pattern, "pixelsizefixupfactor", 0, &pixel_fixup) != FcResultMatch) {
/*
* Force a fixup factor on scalable bitmap fonts (typically
* emoji fonts). The fixup factor is
* requested-pixel-size / actual-pixels-size
*/
if (scalable && !outline) {
font: original -> requested
2019-11-30 12:38:54 +01:00
double requested_pixel_size;
if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &requested_pixel_size) != FcResultMatch) {
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
/* User didn't specify ":pixelsize=xy" */
font: original -> requested
2019-11-30 12:38:54 +01:00
double requested_size;
if (FcPatternGetDouble(pattern, FC_SIZE, 0, &requested_size) != FcResultMatch) {
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
/* User didn't specify ":size=xy" */
font: original -> requested
2019-11-30 12:38:54 +01:00
requested_size = size;
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
}
font: original -> requested
2019-11-30 12:38:54 +01:00
requested_pixel_size = size * dpi / 72;
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
}
font: original -> requested
2019-11-30 12:38:54 +01:00
pixel_fixup = requested_pixel_size / ft_face->size->metrics.y_ppem;
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
LOG_DBG("estimated pixel fixup factor to %f (from pixel size: %f)",
font: original -> requested
2019-11-30 12:38:54 +01:00
pixel_fixup, requested_pixel_size);
font: use pixelsizefixupfactor on regular bitmap fonts too, if set But if it isn't set, only estimate it if the font is a *scalable* non-outline (bitmap) font.
2019-11-28 21:32:28 +01:00
} else
font: add missing ';'
2019-11-28 21:33:45 +01:00
pixel_fixup = 1.;
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
}
#if 0
LOG_DBG("FIXED SIZES: %d", ft_face->num_fixed_sizes);
for (int i = 0; i < ft_face->num_fixed_sizes; i++)
LOG_DBG(" #%d: height=%d, y_ppem=%f", i, ft_face->available_sizes[i].height, ft_face->available_sizes[i].y_ppem / 64.);
#endif
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
FcBool fc_hinting;
font: don't warn when failing to get hinting/antialias These properties aren't always included in the pattern, and when they aren't, trying to get them will fail. This isn't an error, just fallback to a default value.
2019-07-18 10:03:08 +02:00
if (FcPatternGetBool(final_pattern, FC_HINTING,0, &fc_hinting) != FcResultMatch)
font: sync cairo's options with the FC pattern Configure cairo's 'options' with default values, then update the FontConfig pattern. Finally, update the cairo options after having retrieved the final FontConfig option.
2019-07-17 22:50:26 +02:00
fc_hinting = FcTrue;
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
FcBool fc_antialias;
font: don't warn when failing to get hinting/antialias These properties aren't always included in the pattern, and when they aren't, trying to get them will fail. This isn't an error, just fallback to a default value.
2019-07-18 10:03:08 +02:00
if (FcPatternGetBool(final_pattern, FC_ANTIALIAS, 0, &fc_antialias) != FcResultMatch)
font: sync cairo's options with the FC pattern Configure cairo's 'options' with default values, then update the FontConfig pattern. Finally, update the cairo options after having retrieved the final FontConfig option.
2019-07-17 22:50:26 +02:00
fc_antialias = FcTrue;
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
int fc_hintstyle;
if (FcPatternGetInteger(final_pattern, FC_HINT_STYLE, 0, &fc_hintstyle) != FcResultMatch)
fc_hintstyle = FC_HINT_SLIGHT;
int fc_rgba;
if (FcPatternGetInteger(final_pattern, FC_RGBA, 0, &fc_rgba) != FcResultMatch)
fc_rgba = FC_RGBA_UNKNOWN;
int load_flags = 0;
if (!fc_antialias) {
if (!fc_hinting || fc_hintstyle == FC_HINT_NONE)
load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_NO_HINTING | FT_LOAD_TARGET_NORMAL;
else
load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO;
} else {
if (!fc_hinting || fc_hintstyle == FC_HINT_NONE)
load_flags |= FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING | FT_LOAD_TARGET_NORMAL;
else if (fc_hinting && fc_hintstyle == FC_HINT_SLIGHT)
load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LIGHT;
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
else if (fc_rgba == FC_RGBA_RGB || fc_rgba == FC_RGBA_BGR)
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LCD;
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
else if (fc_rgba == FC_RGBA_VRGB || fc_rgba == FC_RGBA_VBGR)
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LCD_V;
else
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_NORMAL;
}
FcBool fc_embeddedbitmap;
if (FcPatternGetBool(final_pattern, FC_EMBEDDED_BITMAP, 0, &fc_embeddedbitmap) != FcResultMatch)
fc_embeddedbitmap = FcTrue;
if (!fc_embeddedbitmap)
load_flags |= FT_LOAD_NO_BITMAP;
int render_flags = 0;
if (!fc_antialias)
render_flags |= FT_RENDER_MODE_MONO;
else {
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
if (fc_rgba == FC_RGBA_RGB || fc_rgba == FC_RGBA_BGR)
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
render_flags |= FT_RENDER_MODE_LCD;
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
else if (fc_rgba == FC_RGBA_VRGB || fc_rgba == FC_RGBA_VBGR)
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
render_flags |= FT_RENDER_MODE_LCD_V;
else
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
render_flags |= FT_RENDER_MODE_NORMAL;
}
int fc_lcdfilter;
if (FcPatternGetInteger(final_pattern, FC_LCD_FILTER, 0, &fc_lcdfilter) != FcResultMatch)
fc_lcdfilter = FC_LCD_DEFAULT;
switch (fc_lcdfilter) {
case FC_LCD_NONE: font->lcd_filter = FT_LCD_FILTER_NONE; break;
case FC_LCD_DEFAULT: font->lcd_filter = FT_LCD_FILTER_DEFAULT; break;
case FC_LCD_LIGHT: font->lcd_filter = FT_LCD_FILTER_LIGHT; break;
case FC_LCD_LEGACY: font->lcd_filter = FT_LCD_FILTER_LEGACY; break;
}
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
font->name = strdup((char *)face_file);
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
FcPatternDestroy(final_pattern);
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
mtx_init(&font->lock, mtx_plain);
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
font->face = ft_face;
font: initial support for double-width *and* color emoji glyphs Fonts are now loaded with FT_LOAD_COLOR and we recognize and support the FT_PIXEL_MODE_BGRA pixel mode. This is mapped to a CAIRO_FORMAT_ARGB32 surface, that is blitted as-is (instead of used as a mask like we do for gray and mono glyphs). Furthermore, since many emojis are double-width, we add initial support for double-width glyphs. These are assumed to always be utf8. When PRINT:ing an utf8 character, we check its width, and add empty "spacer" cells after the cell with the multi-column glyph. When rendering, we render the columns in each row backwards. This ensures the spacer cells get cleared *before* we render the glyph (so that we don't end up erasing part of the glyph). Finally, emoji fonts are usually bitmap fonts with *large* glyphs. These aren't automatically scaled down. I.e. even if we request a glyph of 13 pixels, we might end up getting a 100px glyph. To handle this, fontconfig must be configured to scale bitmap fonts. When it is, we can look at the 'scalable' and 'pixelsizefixup' properties, and use these to scale the rendered glyph.
2019-07-31 18:03:35 +02:00
font->load_flags = load_flags | FT_LOAD_COLOR;
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
font->render_flags = render_flags;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
font->is_fallback = is_fallback;
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
font->pixel_size_fixup = pixel_fixup;
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
font->bgr = fc_rgba == FC_RGBA_BGR || fc_rgba == FC_RGBA_VBGR;
font: cache top-level fonts This greatly improves the performance when loading user-configured fallback fonts. Previously, we had to re-load these fallback fonts over and over again for each (new) glyph.
2019-10-16 22:34:23 +02:00
font->ref_counter = 1;
font: fc_idx may not be the requested one
2019-10-17 17:07:37 +02:00
font->fc_idx = font_idx;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
if (is_fallback) {
font->fc_pattern = NULL;
font->fc_fonts = NULL;
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
font->fc_loaded_fallbacks = NULL;
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
font->glyph_cache = NULL;
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
} else {
font->fc_pattern = !is_fallback ? pattern : NULL;
font->fc_fonts = !is_fallback ? fonts : NULL;
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
font->fc_loaded_fallbacks = calloc(
fonts->nfont, sizeof(font->fc_loaded_fallbacks[0]));
font: cache_size -> glyph_cache_size This makes it more clear it has nothing to do with the font cache.
2019-11-30 12:41:09 +01:00
font->glyph_cache = calloc(glyph_cache_size, sizeof(font->glyph_cache[0]));
font: cleanup
2019-08-10 21:10:56 +02:00
}
font: move metrics from terminal struct to font struct
2019-11-26 18:54:32 +01:00
double max_x_advance = ft_face->size->metrics.max_advance / 64.;
double height= ft_face->size->metrics.height / 64.;
double descent = ft_face->size->metrics.descender / 64.;
double ascent = ft_face->size->metrics.ascender / 64.;
font->height = ceil(height * font->pixel_size_fixup);
font->descent = ceil(-descent * font->pixel_size_fixup);
font->ascent = ceil(ascent * font->pixel_size_fixup);
font->max_x_advance = ceil(max_x_advance * font->pixel_size_fixup);
LOG_DBG("%s: size=%f, pixel-size=%f, dpi=%f, fixup-factor: %f, "
"line-height: %d, ascent: %d, descent: %d, x-advance: %d",
font->name, size, pixel_size, dpi, font->pixel_size_fixup,
font->height, font->ascent, font->descent,
font->max_x_advance);
font: calculate underline/strikeout metrics in font, not main
2019-09-29 13:03:48 +02:00
underline_strikeout_metrics(font);
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
return true;
}
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
static struct font *
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
from_name(const char *name, bool is_fallback)
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
{
LOG_DBG("instantiating %s", name);
FcPattern *pattern = FcNameParse((const unsigned char *)name);
if (pattern == NULL) {
LOG_ERR("%s: failed to lookup font", name);
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
return NULL;
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
}
if (!FcConfigSubstitute(NULL, pattern, FcMatchPattern)) {
LOG_ERR("%s: failed to do config substitution", name);
FcPatternDestroy(pattern);
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
return NULL;
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
}
FcDefaultSubstitute(pattern);
FcResult result;
FcFontSet *fonts = FcFontSort(NULL, pattern, FcTrue, NULL, &result);
if (result != FcResultMatch) {
LOG_ERR("%s: failed to match font", name);
FcPatternDestroy(pattern);
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
return NULL;
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
}
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
struct font *font = malloc(sizeof(*font));
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
if (!from_font_set(pattern, fonts, 0, font, is_fallback)) {
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
free(font);
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
FcFontSetDestroy(fonts);
FcPatternDestroy(pattern);
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
return NULL;
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
}
font: cleanup
2019-08-10 21:10:56 +02:00
if (is_fallback) {
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
FcFontSetDestroy(fonts);
FcPatternDestroy(pattern);
}
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
return font;
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
}
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
font: cache loaded fonts globally Each font instance has a ref-counter. Whenever we want to instantiate a font that has already been loaded, we instead return the already-loaded instance, and bump the ref counter. When the last font instance is destroyed, it is also removed from the cache.
2019-11-01 20:40:42 +01:00
static uint64_t
sdbm_hash(const char *s)
{
uint64_t hash = 0;
for (; *s != '\0'; s++) {
int c = *s;
hash = c + (hash << 6) + (hash << 16) - hash;
}
return hash;
}
static uint64_t
font_hash(font_list_t names, const char *attributes)
{
uint64_t hash = 0;
tll_foreach(names, it)
hash ^= sdbm_hash(it->item);
if (attributes != NULL)
hash ^= sdbm_hash(attributes);
return hash;
}
font: font_from_name() returns an allocated font struct
2019-10-16 21:52:12 +02:00
struct font *
font_from_name(font_list_t names, const char *attributes)
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
{
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
if (tll_length(names) == 0)
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
return false;
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
font: cache loaded fonts globally Each font instance has a ref-counter. Whenever we want to instantiate a font that has already been loaded, we instead return the already-loaded instance, and bump the ref counter. When the last font instance is destroyed, it is also removed from the cache.
2019-11-01 20:40:42 +01:00
uint64_t hash = font_hash(names, attributes);
tll_foreach(font_cache, it) {
if (it->item.hash == hash) {
it->item.font->ref_counter++;
return it->item.font;
}
}
font: load fallback fonts on demand When instantiating a primary font, build the fallback font list, but don't actually instantiate the fallback fonts. Instead, remember the (full) pattern that we should use if/when we instantiate it. Then, when looking up a glyph and we need a fallback font, loop the list and instantiate the font(s) there and then.
2019-10-17 17:53:03 +02:00
struct font *font = NULL;
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
bool have_attrs = attributes != NULL && strlen(attributes) > 0;
size_t attr_len = have_attrs ? strlen(attributes) + 1 : 0;
bool first = true;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
tll_foreach(names, it) {
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
const char *base_name = it->item;
font: load fallback fonts on demand When instantiating a primary font, build the fallback font list, but don't actually instantiate the fallback fonts. Instead, remember the (full) pattern that we should use if/when we instantiate it. Then, when looking up a glyph and we need a fallback font, loop the list and instantiate the font(s) there and then.
2019-10-17 17:53:03 +02:00
char name[strlen(base_name) + attr_len + 1];
strcpy(name, base_name);
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
if (have_attrs) {
font: load fallback fonts on demand When instantiating a primary font, build the fallback font list, but don't actually instantiate the fallback fonts. Instead, remember the (full) pattern that we should use if/when we instantiate it. Then, when looking up a glyph and we need a fallback font, loop the list and instantiate the font(s) there and then.
2019-10-17 17:53:03 +02:00
strcat(name, ":");
strcat(name, attributes);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
if (first) {
first = false;
font: load fallback fonts on demand When instantiating a primary font, build the fallback font list, but don't actually instantiate the fallback fonts. Instead, remember the (full) pattern that we should use if/when we instantiate it. Then, when looking up a glyph and we need a fallback font, loop the list and instantiate the font(s) there and then.
2019-10-17 17:53:03 +02:00
font = from_name(name, false);
if (font == NULL)
return NULL;
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
continue;
}
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
font: load fallback fonts on demand When instantiating a primary font, build the fallback font list, but don't actually instantiate the fallback fonts. Instead, remember the (full) pattern that we should use if/when we instantiate it. Then, when looking up a glyph and we need a fallback font, loop the list and instantiate the font(s) there and then.
2019-10-17 17:53:03 +02:00
assert(font != NULL);
tll_push_back(
font->fallbacks, ((struct font_fallback){.pattern = strdup(name)}));
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
}
font: font_from_name() returns an allocated font struct
2019-10-16 21:52:12 +02:00
font: cache loaded fonts globally Each font instance has a ref-counter. Whenever we want to instantiate a font that has already been loaded, we instead return the already-loaded instance, and bump the ref counter. When the last font instance is destroyed, it is also removed from the cache.
2019-11-01 20:40:42 +01:00
tll_push_back(font_cache, ((struct font_cache_entry){.hash = hash, .font = font}));
font: load fallback fonts on demand When instantiating a primary font, build the fallback font list, but don't actually instantiate the fallback fonts. Instead, remember the (full) pattern that we should use if/when we instantiate it. Then, when looking up a glyph and we need a fallback font, loop the list and instantiate the font(s) there and then.
2019-10-17 17:53:03 +02:00
return font;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
static size_t
hash_index(wchar_t wc)
{
font: cache_size -> glyph_cache_size This makes it more clear it has nothing to do with the font cache.
2019-11-30 12:41:09 +01:00
return wc % glyph_cache_size;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
static bool
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
glyph_for_wchar(const struct font *font, wchar_t wc, struct glyph *glyph)
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
{
font: glyph_for_wchar(): ensure glyph->valid == false, in *all* error cases
2019-10-18 19:50:48 +02:00
*glyph = (struct glyph){
.wc = wc,
.valid = false,
};
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
/*
* LCD filter is per library instance. Thus we need to re-set it
* every time...
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
*
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
* Also note that many freetype builds lack this feature
* (FT_CONFIG_OPTION_SUBPIXEL_RENDERING must be defined, and isn't
* by default) */
FT_Error err = FT_Library_SetLcdFilter(ft_lib, font->lcd_filter);
font: log freetype errors
2019-11-30 12:35:07 +01:00
if (err != 0 && err != FT_Err_Unimplemented_Feature) {
LOG_ERR("failed to set LCD filter: %s", ft_error_string(err));
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
goto err;
font: log freetype errors
2019-11-30 12:35:07 +01:00
}
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
FT_UInt idx = FT_Get_Char_Index(font->face, wc);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
if (idx == 0) {
font: improve logging
2019-08-08 17:57:58 +02:00
/* No glyph in this font, try fallback fonts */
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
tll_foreach(font->fallbacks, it) {
font: load fallback fonts on demand When instantiating a primary font, build the fallback font list, but don't actually instantiate the fallback fonts. Instead, remember the (full) pattern that we should use if/when we instantiate it. Then, when looking up a glyph and we need a fallback font, loop the list and instantiate the font(s) there and then.
2019-10-17 17:53:03 +02:00
if (it->item.font == NULL) {
it->item.font = from_name(it->item.pattern, true);
if (it->item.font == NULL)
continue;
}
if (glyph_for_wchar(it->item.font, wc, glyph)) {
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
LOG_DBG("%C: used fallback: %s", wc, it->item.font->name);
font: from_name() returns an allocated font struct
2019-10-16 22:22:26 +02:00
return true;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
}
if (font->is_fallback)
return false;
font: improve logging
2019-08-08 17:57:58 +02:00
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
/* Try fontconfig fallback fonts */
assert(font->fc_pattern != NULL);
assert(font->fc_fonts != NULL);
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
assert(font->fc_loaded_fallbacks != NULL);
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
assert(font->fc_idx != -1);
for (int i = font->fc_idx + 1; i < font->fc_fonts->nfont; i++) {
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
if (font->fc_loaded_fallbacks[i] == NULL) {
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
/* Load font */
struct font *fallback = malloc(sizeof(*fallback));
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
if (!from_font_set(font->fc_pattern, font->fc_fonts, i, fallback, true))
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
{
LOG_WARN("failed to load fontconfig fallback font");
free(fallback);
continue;
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
}
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
LOG_DBG("loaded new fontconfig fallback font");
font: fc_idx may not be the requested one
2019-10-17 17:07:37 +02:00
assert(fallback->fc_idx >= i);
i = fallback->fc_idx;
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
font->fc_loaded_fallbacks[i] = fallback;
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
}
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
assert(font->fc_loaded_fallbacks[i] != NULL);
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
if (glyph_for_wchar(font->fc_loaded_fallbacks[i], wc, glyph)) {
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
LOG_DBG("%C: used fontconfig fallback: %s",
wc, font->fc_loaded_fallbacks[i]->name);
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
return true;
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
}
}
font: don't spam failures to lookup glyphs
2019-11-20 10:23:17 +01:00
LOG_DBG("%C: no glyph found (in neither the main font, "
"nor any fallback fonts)", wc);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
err = FT_Load_Glyph(font->face, idx, font->load_flags);
if (err != 0) {
font: log freetype errors
2019-11-30 12:35:07 +01:00
LOG_ERR("%s: failed to load glyph #%d: %s",
font->name, idx, ft_error_string(err));
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
goto err;
}
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
err = FT_Render_Glyph(font->face->glyph, font->render_flags);
font: log freetype errors
2019-11-30 12:35:07 +01:00
if (err != 0) {
LOG_ERR("%s: failed to render glyph: %s", font->name, ft_error_string(err));
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
goto err;
font: log freetype errors
2019-11-30 12:35:07 +01:00
}
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
font: populate glyph cache (ASCII characters only) when instantiating font
2019-07-28 21:03:38 +02:00
assert(font->face->glyph->format == FT_GLYPH_FORMAT_BITMAP);
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
FT_Bitmap *bitmap = &font->face->glyph->bitmap;
font: don't bother creating a cairo surface for zero-width glyphs
2019-08-13 20:44:30 +02:00
if (bitmap->width == 0)
goto err;
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
pixman_format_code_t pix_format;
int width;
int rows;
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
switch (bitmap->pixel_mode) {
case FT_PIXEL_MODE_MONO:
pix_format = PIXMAN_a1;
width = bitmap->width;
rows = bitmap->rows;
break;
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
case FT_PIXEL_MODE_GRAY:
pix_format = PIXMAN_a8;
width = bitmap->width;
rows = bitmap->rows;
break;
case FT_PIXEL_MODE_LCD:
pix_format = PIXMAN_x8r8g8b8;
width = bitmap->width / 3;
rows = bitmap->rows;
break;
case FT_PIXEL_MODE_LCD_V:
pix_format = PIXMAN_x8r8g8b8;
width = bitmap->width;
rows = bitmap->rows / 3;
break;
case FT_PIXEL_MODE_BGRA:
pix_format = PIXMAN_a8r8g8b8;
width = bitmap->width;
rows = bitmap->rows;
break;
default:
LOG_ERR("unimplemented: FT pixel mode: %d", bitmap->pixel_mode);
goto err;
break;
}
refactor: break out stride calculation to new function
2019-08-18 17:59:43 +02:00
int stride = stride_for_format_and_width(pix_format, width);
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
assert(stride >= bitmap->pitch);
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
uint8_t *data = malloc(rows * stride);
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
Remove all references to cairo; we now use pixman only
2019-08-16 22:11:22 +02:00
/* Convert FT bitmap to pixman image */
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
switch (bitmap->pixel_mode) {
case FT_PIXEL_MODE_MONO:
for (size_t r = 0; r < bitmap->rows; r++) {
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
for (size_t c = 0; c < (bitmap->width + 7) / 8; c++) {
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
uint8_t v = bitmap->buffer[r * bitmap->pitch + c];
uint8_t reversed = 0;
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
for (size_t i = 0; i < min(8, bitmap->width - c * 8); i++)
reversed |= ((v >> (7 - i)) & 1) << i;
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
data[r * stride + c] = reversed;
}
}
break;
case FT_PIXEL_MODE_GRAY:
for (size_t r = 0; r < bitmap->rows; r++) {
for (size_t c = 0; c < bitmap->width; c++)
data[r * stride + c] = bitmap->buffer[r * bitmap->pitch + c];
}
break;
font: initial support for double-width *and* color emoji glyphs Fonts are now loaded with FT_LOAD_COLOR and we recognize and support the FT_PIXEL_MODE_BGRA pixel mode. This is mapped to a CAIRO_FORMAT_ARGB32 surface, that is blitted as-is (instead of used as a mask like we do for gray and mono glyphs). Furthermore, since many emojis are double-width, we add initial support for double-width glyphs. These are assumed to always be utf8. When PRINT:ing an utf8 character, we check its width, and add empty "spacer" cells after the cell with the multi-column glyph. When rendering, we render the columns in each row backwards. This ensures the spacer cells get cleared *before* we render the glyph (so that we don't end up erasing part of the glyph). Finally, emoji fonts are usually bitmap fonts with *large* glyphs. These aren't automatically scaled down. I.e. even if we request a glyph of 13 pixels, we might end up getting a 100px glyph. To handle this, fontconfig must be configured to scale bitmap fonts. When it is, we can look at the 'scalable' and 'pixelsizefixup' properties, and use these to scale the rendered glyph.
2019-07-31 18:03:35 +02:00
case FT_PIXEL_MODE_BGRA:
assert(stride == bitmap->pitch);
memcpy(data, bitmap->buffer, bitmap->rows * bitmap->pitch);
break;
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
case FT_PIXEL_MODE_LCD:
for (size_t r = 0; r < bitmap->rows; r++) {
for (size_t c = 0; c < bitmap->width; c += 3) {
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
unsigned char _r = bitmap->buffer[r * bitmap->pitch + c + (font->bgr ? 2 : 0)];
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
unsigned char _g = bitmap->buffer[r * bitmap->pitch + c + 1];
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
unsigned char _b = bitmap->buffer[r * bitmap->pitch + c + (font->bgr ? 0 : 2)];
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
uint32_t *p = (uint32_t *)&data[r * stride + 4 * (c / 3)];
*p = _r << 16 | _g << 8 | _b;
}
}
break;
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
case FT_PIXEL_MODE_LCD_V:
/* Unverified */
for (size_t r = 0; r < bitmap->rows; r += 3) {
for (size_t c = 0; c < bitmap->width; c++) {
unsigned char _r = bitmap->buffer[(r + (font->bgr ? 2 : 0)) * bitmap->pitch + c];
unsigned char _g = bitmap->buffer[(r + 1) * bitmap->pitch + c];
unsigned char _b = bitmap->buffer[(r + (font->bgr ? 0 : 2)) * bitmap->pitch + c];
uint32_t *p = (uint32_t *)&data[r / 3 * stride + 4 * c];
*p = _r << 16 | _g << 8 | _b;
}
}
break;
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
default:
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
abort();
break;
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
}
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
pixman_image_t *pix = pixman_image_create_bits_no_clear(
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
pix_format, width, rows, (uint32_t *)data, stride);
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
if (pix == NULL) {
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
free(data);
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
goto err;
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
}
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
pixman_image_set_component_alpha(
pix,
bitmap->pixel_mode == FT_PIXEL_MODE_LCD ||
bitmap->pixel_mode == FT_PIXEL_MODE_LCD_V);
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
if (font->pixel_size_fixup != 1.) {
font: set pixman filter when re-scaling glyph
2019-11-27 21:33:08 +01:00
struct pixman_transform scale;
pixman_transform_init_identity(&scale);
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
pixman_transform_scale(
font: set pixman filter when re-scaling glyph
2019-11-27 21:33:08 +01:00
&scale, NULL,
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
pixman_double_to_fixed(1.0 / font->pixel_size_fixup),
pixman_double_to_fixed(1.0 / font->pixel_size_fixup));
font: set pixman filter when re-scaling glyph
2019-11-27 21:33:08 +01:00
pixman_image_set_transform(pix, &scale);
pixman_image_set_filter(pix, PIXMAN_FILTER_BEST, NULL, 0);
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
}
font: never set glyph->cols to something that is less than 0
2019-11-30 00:15:54 +01:00
int cols = wcwidth(wc);
if (cols < 0)
cols = 0;
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
*glyph = (struct glyph){
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
.wc = wc,
font: never set glyph->cols to something that is less than 0
2019-11-30 00:15:54 +01:00
.cols = cols,
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
.pix = pix,
font: estimate pixel size fixup when not provided by fontconfig But only do this when the font is scalable but not an outline. This is only true for color bitmap fonts (emoji fonts), and not e.g. regular bitmap fonts.
2019-11-26 19:00:21 +01:00
.x = font->face->glyph->bitmap_left * font->pixel_size_fixup,
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
.y = font->face->glyph->bitmap_top * font->pixel_size_fixup,
font: implement subpixel antialiasing
2019-08-18 17:40:57 +02:00
.width = width,
.height = rows,
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
.valid = true,
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
};
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
return true;
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
err:
font: glyph_for_wchar(): ensure glyph->valid == false, in *all* error cases
2019-10-18 19:50:48 +02:00
assert(!glyph->valid);
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
return false;
font: add font_glyph_for_utf8() This function fills in a struct glyph with glyph bitmap data for the provided utf-8 character (essentially a FT_Bitmap wrapped in a cairo surface).
2019-07-28 20:37:59 +02:00
}
font: populate glyph cache (ASCII characters only) when instantiating font
2019-07-28 21:03:38 +02:00
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
const struct glyph *
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
font_glyph_for_wc(struct font *font, wchar_t wc)
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
{
mtx_lock(&font->lock);
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
assert(font->glyph_cache != NULL);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
size_t hash_idx = hash_index(wc);
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
hash_entry_t *hash_entry = font->glyph_cache[hash_idx];
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
if (hash_entry != NULL) {
tll_foreach(*hash_entry, it) {
if (it->item.wc == wc) {
mtx_unlock(&font->lock);
font: handle invalid glyphs correctly *All* glyphs are cached. But we never set the 'wc' member of failed glyphs, causing a later cache lookup of the same glyph miss in the cache, and thus re-generate yet another glyph (that is inserted into the cache). I.e. if the same (invalid) glyph is rendered over and over again, we'll end up growing the cache indefinitely. Fix by setting the 'wc' member of invalid glyphs. This causes a cache lookup to hit. But, we must also check the glyphs validity, and return NULL if the glyph isn't valid. Finally, when destroying a font, skip invalid glyphs, since they have no resources that needs to be freed.
2019-08-13 20:41:21 +02:00
return it->item.valid ? &it->item : NULL;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
}
}
struct glyph glyph;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
bool got_glyph = glyph_for_wchar(font, wc, &glyph);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
if (hash_entry == NULL) {
hash_entry = calloc(1, sizeof(*hash_entry));
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
assert(font->glyph_cache[hash_idx] == NULL);
font->glyph_cache[hash_idx] = hash_entry;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
font: don't bother creating a cairo surface for zero-width glyphs
2019-08-13 20:44:30 +02:00
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
assert(hash_entry != NULL);
tll_push_back(*hash_entry, glyph);
mtx_unlock(&font->lock);
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
return got_glyph ? &tll_back(*hash_entry) : NULL;
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
font: populate glyph cache (ASCII characters only) when instantiating font
2019-07-28 21:03:38 +02:00
void
font_destroy(struct font *font)
{
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
if (font == NULL)
return;
font: cache top-level fonts This greatly improves the performance when loading user-configured fallback fonts. Previously, we had to re-load these fallback fonts over and over again for each (new) glyph.
2019-10-16 22:34:23 +02:00
if (--font->ref_counter > 0)
return;
font: cache loaded fonts globally Each font instance has a ref-counter. Whenever we want to instantiate a font that has already been loaded, we instead return the already-loaded instance, and bump the ref counter. When the last font instance is destroyed, it is also removed from the cache.
2019-11-01 20:40:42 +01:00
tll_foreach(font_cache, it) {
if (it->item.font == font) {
tll_remove(font_cache, it);
break;
}
}
font: load all fallbacks when instantiating a primary font The caching of fallback fonts didn't work. It "worked" because we didn't free the fonts... When we started doing that, the fallback fonts were no longer cached. Another solution would have been to keep the cached fallback fonts around until exit, and free them there. But that didn't seem very clean. So, for now, load *all* fallbacks when instantiating a primary (non-fallback) font. Note that this slows down initial startup time.
2019-10-17 17:43:40 +02:00
free(font->name);
font: load fallback fonts on demand When instantiating a primary font, build the fallback font list, but don't actually instantiate the fallback fonts. Instead, remember the (full) pattern that we should use if/when we instantiate it. Then, when looking up a glyph and we need a fallback font, loop the list and instantiate the font(s) there and then.
2019-10-17 17:53:03 +02:00
tll_foreach(font->fallbacks, it) {
font_destroy(it->item.font);
free(it->item.pattern);
}
tll_free(font->fallbacks);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
if (font->face != NULL) {
mtx_lock(&ft_lock);
font: populate glyph cache (ASCII characters only) when instantiating font
2019-07-28 21:03:38 +02:00
FT_Done_Face(font->face);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
mtx_unlock(&ft_lock);
}
font: populate glyph cache (ASCII characters only) when instantiating font
2019-07-28 21:03:38 +02:00
font: initial support for double-width *and* color emoji glyphs Fonts are now loaded with FT_LOAD_COLOR and we recognize and support the FT_PIXEL_MODE_BGRA pixel mode. This is mapped to a CAIRO_FORMAT_ARGB32 surface, that is blitted as-is (instead of used as a mask like we do for gray and mono glyphs). Furthermore, since many emojis are double-width, we add initial support for double-width glyphs. These are assumed to always be utf8. When PRINT:ing an utf8 character, we check its width, and add empty "spacer" cells after the cell with the multi-column glyph. When rendering, we render the columns in each row backwards. This ensures the spacer cells get cleared *before* we render the glyph (so that we don't end up erasing part of the glyph). Finally, emoji fonts are usually bitmap fonts with *large* glyphs. These aren't automatically scaled down. I.e. even if we request a glyph of 13 pixels, we might end up getting a 100px glyph. To handle this, fontconfig must be configured to scale bitmap fonts. When it is, we can look at the 'scalable' and 'pixelsizefixup' properties, and use these to scale the rendered glyph.
2019-07-31 18:03:35 +02:00
mtx_destroy(&font->lock);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
if (font->fc_fonts != NULL) {
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
assert(font->fc_loaded_fallbacks != NULL);
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
for (size_t i = 0; i < font->fc_fonts->nfont; i++)
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
font_destroy(font->fc_loaded_fallbacks[i]);
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
free(font->fc_loaded_fallbacks);
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
}
font: initial support for fontconfig font fallback When we've exhausted our own fallback list, try the font list provided by fontconfig. This means, the user's fallback fonts have priority, but in case all of them fail, we hopefully get lucky with fontconfig...
2019-08-10 20:34:22 +02:00
if (font->fc_pattern != NULL)
FcPatternDestroy(font->fc_pattern);
if (font->fc_fonts != NULL)
FcFontSetDestroy(font->fc_fonts);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
font: cache_size -> glyph_cache_size This makes it more clear it has nothing to do with the font cache.
2019-11-30 12:41:09 +01:00
for (size_t i = 0; i < glyph_cache_size && font->glyph_cache != NULL; i++) {
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
if (font->glyph_cache[i] == NULL)
font: initial support for double-width *and* color emoji glyphs Fonts are now loaded with FT_LOAD_COLOR and we recognize and support the FT_PIXEL_MODE_BGRA pixel mode. This is mapped to a CAIRO_FORMAT_ARGB32 surface, that is blitted as-is (instead of used as a mask like we do for gray and mono glyphs). Furthermore, since many emojis are double-width, we add initial support for double-width glyphs. These are assumed to always be utf8. When PRINT:ing an utf8 character, we check its width, and add empty "spacer" cells after the cell with the multi-column glyph. When rendering, we render the columns in each row backwards. This ensures the spacer cells get cleared *before* we render the glyph (so that we don't end up erasing part of the glyph). Finally, emoji fonts are usually bitmap fonts with *large* glyphs. These aren't automatically scaled down. I.e. even if we request a glyph of 13 pixels, we might end up getting a 100px glyph. To handle this, fontconfig must be configured to scale bitmap fonts. When it is, we can look at the 'scalable' and 'pixelsizefixup' properties, and use these to scale the rendered glyph.
2019-07-31 18:03:35 +02:00
continue;
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
tll_foreach(*font->glyph_cache[i], it) {
font: handle invalid glyphs correctly *All* glyphs are cached. But we never set the 'wc' member of failed glyphs, causing a later cache lookup of the same glyph miss in the cache, and thus re-generate yet another glyph (that is inserted into the cache). I.e. if the same (invalid) glyph is rendered over and over again, we'll end up growing the cache indefinitely. Fix by setting the 'wc' member of invalid glyphs. This causes a cache lookup to hit. But, we must also check the glyphs validity, and return NULL if the glyph isn't valid. Finally, when destroying a font, skip invalid glyphs, since they have no resources that needs to be freed.
2019-08-13 20:41:21 +02:00
if (!it->item.valid)
continue;
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
void *image = pixman_image_get_data(it->item.pix);
pixman_image_unref(it->item.pix);
font: initial support for double-width *and* color emoji glyphs Fonts are now loaded with FT_LOAD_COLOR and we recognize and support the FT_PIXEL_MODE_BGRA pixel mode. This is mapped to a CAIRO_FORMAT_ARGB32 surface, that is blitted as-is (instead of used as a mask like we do for gray and mono glyphs). Furthermore, since many emojis are double-width, we add initial support for double-width glyphs. These are assumed to always be utf8. When PRINT:ing an utf8 character, we check its width, and add empty "spacer" cells after the cell with the multi-column glyph. When rendering, we render the columns in each row backwards. This ensures the spacer cells get cleared *before* we render the glyph (so that we don't end up erasing part of the glyph). Finally, emoji fonts are usually bitmap fonts with *large* glyphs. These aren't automatically scaled down. I.e. even if we request a glyph of 13 pixels, we might end up getting a 100px glyph. To handle this, fontconfig must be configured to scale bitmap fonts. When it is, we can look at the 'scalable' and 'pixelsizefixup' properties, and use these to scale the rendered glyph.
2019-07-31 18:03:35 +02:00
free(image);
font: add support for fallback fonts A top-level font now has a list of fallback fonts. When a glyph cannot be found, we try each fallback font in turn, until we either find one that has the glyph, or until we've exhausted the list. To make this actually work in practise (read: to make performance acceptable), the cache is re-worked and is now populated on demand. It also supports non-ASCII characters, by using the 4-byte unicode character as index instead. Since having an array that can be indexed by a 4-byte value isn't really viable, we now have a simple hash table instead of an array.
2019-07-30 18:04:28 +02:00
}
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
tll_free(*font->glyph_cache[i]);
free(font->glyph_cache[i]);
font: populate glyph cache (ASCII characters only) when instantiating font
2019-07-28 21:03:38 +02:00
}
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
free(font->glyph_cache);
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
free(font);
font: populate glyph cache (ASCII characters only) when instantiating font
2019-07-28 21:03:38 +02:00
}
Reference in a new issue Copy permalink