From 0dd12fd2c4d96a56fe6ba2df6c1aa264b77c9185 Mon Sep 17 00:00:00 2001
From: Declan Tsien <declantsien@riseup.net>
Date: Thu, 31 Aug 2023 11:59:35 +0800
Subject: [PATCH 1/2] Add fontconfig support for font dirs and generic names

---
 Cargo.toml                 |  3 ++
 src/layout/font/builder.rs | 89 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 90 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 10aaba4..c799e09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,5 +13,8 @@ memmap2 = "0.2.1"
 glutin = "0.26.0"
 clipboard2 = "0.1.1"
 
+[target.'cfg(all(unix, not(any(target_os = "macos", target_os = "android"))))'.dependencies]
+fontconfig-parser = "0.5"
+
 [build-dependencies]
 gl_generator = "0.14"
diff --git a/src/layout/font/builder.rs b/src/layout/font/builder.rs
index c5f6c85..784e48f 100644
--- a/src/layout/font/builder.rs
+++ b/src/layout/font/builder.rs
@@ -3,14 +3,14 @@ use super::index_data::*;
 use super::library::FontLibrary;
 use super::system::{Os, OS};
 use super::types::*;
-use crate::util::{string::SmallString};
+use crate::util::string::SmallString;
 use std::{
     fs,
     path::{Path, PathBuf},
     sync::RwLock,
     time::SystemTime,
 };
-use swash::{CacheKey, Attributes, FontDataRef, FontRef, Stretch, StringId, Style, Weight};
+use swash::{Attributes, CacheKey, FontDataRef, FontRef, Stretch, StringId, Style, Weight};
 
 /// Hint for specifying whether font files should be memory mapped.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -137,6 +137,22 @@ impl FontLibraryBuilder {
 
     /// Builds a library for the current configuration.
     pub fn build(&mut self) -> FontLibrary {
+        #[cfg(all(unix, not(any(target_os = "macos", target_os = "android"))))]
+        let fontconfig = load_fontconfig();
+        #[cfg(all(unix, not(any(target_os = "macos", target_os = "android"))))]
+        {
+            let home = std::env::var("HOME");
+            fontconfig.dirs.iter().for_each(|dir| {
+                if dir.path.starts_with("~") {
+                    if let Ok(ref home) = home {
+                        let path = Path::new(home).join(dir.path.strip_prefix("~").unwrap());
+                        self.add_dir(path);
+                    }
+                } else {
+                    self.add_dir(dir.clone().path);
+                };
+            });
+        }
         let mut index = StaticIndex::default();
         core::mem::swap(&mut index, &mut self.inner.index);
         for family in index.families.iter_mut() {
@@ -150,6 +166,42 @@ impl FontLibraryBuilder {
         if self.fallbacks {
             index.setup_default_fallbacks();
         }
+
+        #[cfg(all(unix, not(any(target_os = "macos", target_os = "android"))))]
+        {
+            use fontconfig_parser::Alias;
+
+            if self.generics {
+                fontconfig.aliases.iter().for_each(
+                    |Alias {
+                         alias,
+                         default,
+                         prefer,
+                         accept,
+                     }| {
+                        let names = [&prefer[..], &accept[..], &default[..]].concat();
+                        let find_family = |families: Vec<String>| {
+                            for family in families {
+                                if let Some(id) = index
+                                    .base
+                                    .family_map
+                                    .get(family.trim().to_lowercase().as_str())
+                                {
+                                    return Some(*id);
+                                }
+                            }
+                            None
+                        };
+                        if let Some(generic_family) = GenericFamily::parse(alias) {
+                            if let Some(id) = find_family(names.clone()) {
+                                index.generic[generic_family as usize] = Some(id);
+                            };
+                        }
+                    },
+                )
+            }
+        }
+
         FontLibrary::new(index)
     }
 }
@@ -474,3 +526,36 @@ impl Scanner {
         Some(())
     }
 }
+
+#[cfg(all(unix, not(any(target_os = "macos", target_os = "android"))))]
+fn load_fontconfig() -> fontconfig_parser::FontConfig {
+    let mut fontconfig = fontconfig_parser::FontConfig::default();
+    let home = std::env::var("HOME");
+
+    if let Ok(ref config_file) = std::env::var("FONTCONFIG_FILE") {
+        let _ = fontconfig.merge_config(Path::new(config_file));
+    } else {
+        let xdg_config_home = if let Ok(val) = std::env::var("XDG_CONFIG_HOME") {
+            Some(val.into())
+        } else if let Ok(ref home) = home {
+            // according to https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+            // $XDG_CONFIG_HOME should default to $HOME/.config if not set
+            Some(Path::new(home).join(".config"))
+        } else {
+            None
+        };
+
+        let read_global = match xdg_config_home {
+            Some(p) => fontconfig
+                .merge_config(&p.join("fontconfig/fonts.conf"))
+                .is_err(),
+            None => true,
+        };
+
+        if read_global {
+            let _ = fontconfig.merge_config(Path::new("/etc/fonts/local.conf"));
+        }
+        let _ = fontconfig.merge_config(Path::new("/etc/fonts/fonts.conf"));
+    }
+    fontconfig
+}

From d32eb19e0eaf5bc09ec7d84c01053c4f7dc9a811 Mon Sep 17 00:00:00 2001
From: Declan Tsien <declantsien@riseup.net>
Date: Thu, 31 Aug 2023 14:21:12 +0800
Subject: [PATCH 2/2] Auto detect generic when creating FamilyKey from str

---
 src/layout/font/types.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/layout/font/types.rs b/src/layout/font/types.rs
index bb08f54..67dd033 100644
--- a/src/layout/font/types.rs
+++ b/src/layout/font/types.rs
@@ -74,7 +74,11 @@ pub enum FamilyKey<'a> {
 
 impl<'a> From<&'a str> for FamilyKey<'a> {
     fn from(name: &'a str) -> Self {
-        Self::Name(name)
+        if let Some(generic_family) = GenericFamily::parse(name) {
+            Self::Generic(generic_family)
+        } else {
+            Self::Name(name)
+        }
     }
 }