Do not crash on missing fonts

Author: WhatAmISupposedToPutHere

src/config.rs

@@ -48,7 +48,10 @@ fn load_font(name: &str) -> FontFace {
     let fontconfig = FontConfig::new();
     let mut pattern = Pattern::new(name);
     fontconfig.perform_substitutions(&mut pattern);
-    let pat_match = fontconfig.match_pattern(&pattern);
+    let pat_match = match fontconfig.match_pattern(&pattern) {
+        Ok(pat) => pat,
+        Err(_) => panic!("Unable to find specified font. If you are using the default config, make sure you have at least one font installed")
+    };
     let file_name = pat_match.get_file_name();
     let file_idx = pat_match.get_font_index();
     let ft_library = FtLibrary::init().unwrap();

src/fonts.rs

@@ -1,3 +1,4 @@
+#![allow(non_upper_case_globals)]
 use std::ffi::{c_char, c_int, CStr, CString};
 use std::ptr;
 
@@ -9,11 +10,21 @@ struct FcPattern {
 struct FcConfig {
     _data: [u8; 0]
 }
+
 type FcResult = c_int;
+const FcResultMatch: FcResult = 0;
+const FcResultNoMatch: FcResult = 1;
+const FcResultTypeMismatch: FcResult = 2;
+const FcResultNoId: FcResult = 3;
+const FcResultOutOfMemory: FcResult = 4;
+
 type FcMatchKind = c_int;
-#[allow(non_upper_case_globals)]
 const FcMatchPattern: FcMatchKind = 0;
 
+pub enum FontConfigError {
+    FontNotFound
+}
+
 pub struct FontConfig {
     config: *const FcConfig
 }
@@ -27,18 +38,23 @@ impl FontConfig {
             config
         }
     }
-    pub fn match_pattern(&self, pattern: &Pattern) -> Pattern {
+    pub fn match_pattern(&self, pattern: &Pattern) -> Result<Pattern, FontConfigError> {
         let mut result: FcResult = 0;
         let match_ = unsafe {
             FcFontMatch(self.config, pattern.pattern, &mut result)
         };
-        Pattern {
-            pattern: match_
+        if match_ == ptr::null_mut() {
+            return Err(FontConfigError::FontNotFound);
         }
+        Ok(Pattern {
+            pattern: match_
+        })
     }
     pub fn perform_substitutions(&self, pattern: &mut Pattern) {
         unsafe {
-            FcConfigSubstitute(self.config, pattern.pattern, FcMatchPattern);
+            if (FcConfigSubstitute(self.config, pattern.pattern, FcMatchPattern)) == 0 {
+                panic!("Allocation error while loading fontconfig data");
+            }
             FcDefaultSubstitute(pattern.pattern);
         }
     }
@@ -52,6 +68,27 @@ impl Drop for FontConfig {
     }
 }
 
+fn throw_on_fcpattern_result(res: FcResult) {
+    match res {
+        FcResultMatch => {},
+        FcResultNoMatch => {
+            panic!("NULL pattern");
+        },
+        FcResultTypeMismatch => {
+            panic!("Wrong type for pattern element");
+        },
+        FcResultNoId => {
+            panic!("Unknown pattern element");
+        },
+        FcResultOutOfMemory => {
+            panic!("Out of memory");
+        },
+        r => {
+            panic!("Unknown fontconfig return value {:?}", r)
+        }
+    }
+}
+
 pub struct Pattern {
     pattern: *const FcPattern
 }
@@ -70,15 +107,17 @@ impl Pattern {
         let name = CString::new("file").unwrap();
         unsafe {
             let mut file_name = ptr::null();
-            FcPatternGetString(self.pattern, name.as_ptr(), 0, &mut file_name);
+            let res = FcPatternGetString(self.pattern, name.as_ptr(), 0, &mut file_name);
+            throw_on_fcpattern_result(res);
             CStr::from_ptr(file_name).to_str().unwrap()
         }
     }
     pub fn get_font_index(&self) -> isize {
         let name = CString::new("index").unwrap();
         unsafe {
             let mut index = 0;
-            FcPatternGetInteger(self.pattern, name.as_ptr(), 0, &mut index);
+            let res = FcPatternGetInteger(self.pattern, name.as_ptr(), 0, &mut index);
+            throw_on_fcpattern_result(res);
             index as isize
         }
     }