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.h

76 lines
1.4 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
#pragma once
font: load FreeType face, and set it's pixel sizes
2019-07-28 12:09:22 +02:00
#include <stdbool.h>
font: set FT load and render flags from FontConfig properties
2019-07-29 20:10:55 +02:00
#include <threads.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 <ft2build.h>
#include FT_FREETYPE_H
#include FT_LCD_FILTER_H
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
#include <fontconfig/fontconfig.h>
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
#include <pixman.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: 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 "tllist.h"
//#include "terminal.h"
typedef tll(const char *) font_list_t;
struct glyph {
wchar_t wc;
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
int cols;
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
wip: render background and glyphs using pixman
2019-08-16 20:40:32 +02:00
pixman_image_t *pix;
int x;
int y;
int width;
int height;
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
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 valid;
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
};
typedef tll(struct glyph) hash_entry_t;
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_fallback {
char *pattern;
struct font *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
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
char *name;
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
mtx_t 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
FT_Face face;
int load_flags;
int render_flags;
FT_LcdFilter lcd_filter;
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +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
double pixel_size_fixup; /* Scale factor - should only be used with ARGB32 glyphs */
font: tentative support for BGR, V-RGB and V-BGR
2019-08-19 17:45:21 +02:00
bool bgr; /* True for FC_RGBA_BGR and FC_RGBA_VBGR */
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: 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 {
render: replace all usage of cairo with pixman
2019-08-16 22:06:06 +02:00
int position;
int 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
} underline;
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: 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 {
render: replace all usage of cairo with pixman
2019-08-16 22:06:06 +02:00
int position;
int 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
} strikeout;
bool is_fallback;
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(struct font_fallback) 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
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
size_t ref_counter;
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
/* Fields below are only valid for non-fallback fonts */
FcPattern *fc_pattern;
FcFontSet *fc_fonts;
int fc_idx;
font: rename fc_loaded_fonts -> fc_loaded_fallbacks
2019-10-17 17:06:42 +02:00
struct font **fc_loaded_fallbacks; /* fc_fonts->nfont array */
font: cache loaded fontconfig fallback fonts
2019-10-16 22:18:57 +02:00
font: rename cache -> glyph_cache
2019-10-17 17:12:04 +02:00
hash_entry_t **glyph_cache;
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: 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);
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
const struct glyph *font_glyph_for_wc(struct font *font, wchar_t wc);
font: populate glyph cache (ASCII characters only) when instantiating font
2019-07-28 21:03:38 +02:00
void font_destroy(struct font *font);
Reference in a new issue Copy permalink