System default font as the default font

[lj94093]

I don't know why we must specify a font file to load while develop in egui？It's very annoyed to specify a font while i am a non-native english speaker.While we developing a gui program with gtk or qt,we never need to think what font we should use.

Maybe we could automatically find a local font file by get the system default language and the system default font storage position in Windows,Linux and Mac.If we can't find it,then we could use default font embed in egui.

If my suggestion is valuable,please let me know.I'd glad to make a PR.

[emilk]

Automatically loading the system font (at least as a falback for non latin characters) would be a very nice feature of eframe. Feel free to work on it!

[lj94093]

I encounted some problem while load font from system.I can't find a function to load font from user's system (intead of mine) while program is running.
All i can find is the FontData Struct which accept a 'static bytes which means the font data will be hard encoded to binary.

[emilk]

Then you need to read the docs better: https://docs.rs/epaint/latest/epaint/text/struct.FontData.html#method.from_owned

[lj94093]

After a period of search and code.I find that windows system default font "Segoe UI" support various language.
But After I load the font C:\\WINDOWS\\FONTS\\SEGOEUI.TTF the examples/hello_world.rs still can't input Chinese.
If I load the font named "宋体",then it can input Chinese.
I used the FontForge to open the C:\\WINDOWS\\FONTS\\SEGOEUI.TTF,then I can see there are Chinese character in the font file.

Here is my code inserted in epaint/src/text/fonts.rs

if let Ok(buf) = fs::read("C:\\WINDOWS\\FONTS\\SEGOEUI.TTF") {
    font_data.insert("Segoe UI".to_owned(), FontData::from_owned(buf));
    families.insert(FontFamily::Monospace, vec!["Segoe UI".to_owned()]);
    families.insert(FontFamily::Proportional, vec!["Segoe UI".to_owned()]);
}

What's the problem of my code?

[Mingun]

I can see there are Chinese character in the font file.

Are you sure? It seems to me that it is the Chinese characters that are absent in the font. The characters that you see just show the Unicode point that is assigned for the square placeholder

[leateng]

Load system font

let font = std::fs::read("c:/Windows/Fonts/msyh.ttc").unwrap();
fonts.font_data.insert(
    "my_font".to_owned(),
    egui::FontData::from_owned(font)
);

[lj94093]

tried the "/System/Library/Fonts/Helvetica.ttc" which is the default system font on MacOS and still can't input Chinese.
Use the FontForge to open the file,also could see Chinese characters in it.

[leateng]

@lj94093 @tami5 SEGOEUI and Helvetica font do not support Chinese character. You can try msyh(微软雅黑) font on windows.
https://github.com/googlefonts/noto-fonts this font support all CJK character.

[leateng]

I think there are some font fallback mechanism in OS native widget.
For example, SEGOEUI is the default font in windows, but when drawing Chinese character, fallback to songti.

https://github.com/servo/font-kit font-kit could find all fonts in OS. Maybe helpful to you.

[lj94093]

Actually I was using the font-kit exactly.What bothers me is that I don't know which font should I choose if I want pull a MR to eframe.I could use songti, but if someone speak Japanese use the app,I wish the eframe could load the Japanese font.
So my problem is how to find a font corresponding to the system locale?

[Titaniumtown]

I think there are some font fallback mechanism in OS native widget.
For example, SEGOEUI is the default font in windows, but when drawing Chinese character, fallback to songti.

https://github.com/servo/font-kit font-kit could find all fonts in OS. Maybe helpful to you.

would be cool if font-kit also supported wasm and fetched the fonts from some CDN.

[emilk]

Others have gotten Chinese to work, e.g. with https://github.com/emilk/egui/files/7739412/sarasa-mono-sc-nerd-regular.zip

Are you adding it like shown in https://github.com/emilk/egui/blob/master/examples/custom_font/src/main.rs / https://github.com/emilk/egui/blob/0.17.0/eframe/examples/custom_font.rs ?

[lj94093]

Sorry for careless about the FontForge.I found that the Chinese character in the fontforge is just a label instead of the supported character.

[lj94093]

After reading about the source of druid,I found that piet-direct2d maybe would load the fonts from system according to the input characters dynamically.
So maybe i shouldn't try to load a font file on app boot.
If user input a character that we don't support by default,then we could according to the font size,height,code point and other property to find a system installed font.

[lj94093]

Found a solution for font fallback in neovide which mention a algorithm named harfbuzz.
There is a lib rustybuzz implement this algorithm,but it seems a lib combine text shaping and font fallback while egui already have epaint for text shaping.
So maybe we could implement this algorithm in epaint by add a dependency for skia-safe inspired by neovim/src/renderer/fonts/font_loader.rs.
If this is accepted,please let me know and i will trying to pull a PR for reconstruct the epaint to support font fallback

[emilk]

A PR that adds dynamic font loading to egui would be awesome!

Please make sure it is designed in such a way so that it is backend agnostic. egui is designed to work anywhere, including wasm on web and wasm outside of web (running in e.g. wasmtime). So a plugin-system is required (e.g. egui_ctx.add_font_loader(Box::new(MySystemFontLoader::new(…)))

[jiakuan]

Really useful feature, any updates for the PR? If need any help, please let me know, will be happy to test etc.

[Lydanne]

Expect this function.

[fralonra]

An example using font-kit:

use std::fs::read;

use eframe::{
    egui::{Context, FontData, FontDefinitions},
    epaint::FontFamily,
};
use font_kit::{
    family_name::FamilyName, handle::Handle, properties::Properties, source::SystemSource,
};

fn load_system_font(ctx: &Context) {
    let mut fonts = FontDefinitions::default();

    let handle = SystemSource::new()
        .select_best_match(&[FamilyName::SansSerif], &Properties::new())
        .unwrap();

    let buf: Vec<u8> = match handle {
        Handle::Memory { bytes, .. } => bytes.to_vec(),
        Handle::Path { path, .. } => read(path).unwrap(),
    };

    const FONT_SYSTEM_SANS_SERIF: &'static str = "System Sans Serif";

    fonts
        .font_data
        .insert(FONT_SYSTEM_SANS_SERIF.to_owned(), FontData::from_owned(buf));

    if let Some(vec) = fonts.families.get_mut(&FontFamily::Proportional) {
        vec.push(FONT_SYSTEM_SANS_SERIF.to_owned());
    }

    if let Some(vec) = fonts.families.get_mut(&FontFamily::Monospace) {
        vec.push(FONT_SYSTEM_SANS_SERIF.to_owned());
    }

    ctx.set_fonts(fonts);
}

[stfnp]

In case anyone else also had problems getting the above code to work: The reason might be the line

let mut fonts = FontDefinitions::default();

because the default() function behaves differently depending on the feature default_fonts. If that feature is enabled, the created FontDefinitions already contain the egui default fonts, which then take precedence over the system fonts that are added later. So in my use case (latin characters only) I didn't see any difference.

One solution is to explicitly create empty FontDefinitions instead:

let mut fonts = FontDefinitions::empty();

The other solution is to keep the default fonts as a fallback but change the lines where the system fonts are added from

vec.push(FONT_SYSTEM_SANS_SERIF.to_owned());

to using insert instead of push in order to give them a higher precedence:

vec.insert(0, FONT_SYSTEM_SANS_SERIF.to_owned());

With these changes it seems to work really well though! I wonder how far off this is from something that could be included in egui/eframe.

[woelper]

If it helps anyone, this is what I came up with in oculante based on previous replies in order to have fallback for different languages (embedding them all made the binary too large). It is not pretty but it seems to work on Linux/Windows/Mac.

/// Attempt to load a system font by any of the given `family_names`, returning the first match.
fn load_font_family(family_names: &[&str]) -> Option<Vec<u8>> {
    let system_source = SystemSource::new();

    for &name in family_names {
        match system_source
            .select_best_match(&[FamilyName::Title(name.to_string())], &Properties::new())
        {
            Ok(h) => match &h {
                Handle::Memory { bytes, .. } => {
                    debug!("Loaded {name} from memory.");
                    return Some(bytes.to_vec());
                }
                Handle::Path { path, .. } => {
                    info!("Loaded {name} from path: {:?}", path);
                    if let Ok(data) = read(path) {
                        return Some(data);
                    }
                }
            },
            Err(e) => error!("Could not load {}: {:?}", name, e),
        }
    }

    None
}

pub fn load_system_fonts(mut fonts: FontDefinitions) -> FontDefinitions {
    let mut fontdb = HashMap::new();

    fontdb.insert(
        "simplified_chinese",
        vec![
            "Heiti SC",
            "Songti SC",
            "Noto Sans CJK SC", // Good coverage for Simplified Chinese
            "Noto Sans SC",
            "WenQuanYi Zen Hei", // INcludes both Simplified and Traditional Chinese.
            "SimSun",
            "Noto Sans SC",
            "PingFang SC",
            "Source Han Sans CN",
        ],
    );

    fontdb.insert("korean", vec!["Source Han Sans KR"]);

    fontdb.insert(
        "arabic_fonts",
        vec![
            "Noto Sans Arabic",
            "Amiri",
            "Lateef",
            "Al Tarikh",
            "Segoe UI",
        ],
    );

   // Add more stuff here for better language support

    for (region, font_names) in fontdb {
        if let Some(font_data) = load_font_family(&font_names) {
            info!("Inserting font {region}");
            fonts
                .font_data
                .insert(region.to_owned(), FontData::from_owned(font_data));

            fonts
                .families
                .get_mut(&FontFamily::Proportional)
                .unwrap()
                .push(region.to_owned());
        }
    }
    fonts
}