Implement checking if the font familly exists in pango

piet-cairo/src/text.rs

@@ -1,5 +1,6 @@
 //! Text functionality for Piet cairo backend
 
+use std::cmp::Ordering;
 use std::convert::TryInto;
 use std::fmt;
 use std::ops::{Range, RangeBounds};
@@ -8,7 +9,10 @@ use std::rc::Rc;
 use glib::translate::{from_glib_full, ToGlibPtr};
 
 use pango::prelude::FontMapExt;
-use pango::AttrList;
+use pango::prelude::{FontExt, FontFaceExt};
+use pango::prelude::{FontFamilyExt, FontsetExt};
+use pango::{AttrList, Context};
+use pango::{FontDescription, Language};
 use pango_sys::pango_attr_insert_hyphens_new;
 use pangocairo::FontMap;
 
@@ -166,8 +170,119 @@ impl Text for CairoText {
     type TextLayoutBuilder = CairoTextLayoutBuilder;
 
     fn font_family(&mut self, family_name: &str) -> Option<FontFamily> {
-        //TODO: Veryify that a family exists with the requested name
-        Some(FontFamily::new_unchecked(family_name))
+        // We first do a case-insensitive match for the familly name
+        // After that we get the family which has the best matching  font description.
+        let font = FontDescription::from_string(family_name);
+
+        // println!(
+        //     "{:?}",
+        //     self.pango_context
+        //         .list_families()
+        //         .iter()
+        //         .map(|family| family.name().unwrap())
+        //         .collect::<Vec<glib::GString>>()
+        // );
+
+        // Option 1:
+        // println!(
+        //     "{:?}",
+        //     self.pango_context
+        //         .font_map()
+        //         .unwrap()
+        //         .load_font(&Context::default(), &font)
+        //         .unwrap()
+        //         .describe()
+        //         .unwrap()
+        //         .to_string()
+        // );
+        // let fam = self
+        //     .pango_context
+        //     .font_map()
+        //     .unwrap()
+        //     .load_font(&Context::default(), &font)
+        //     .unwrap()
+        //     .describe()
+        //     .unwrap()
+        //     .to_string();
+        // Some(FontFamily::new_unchecked(fam))
+
+        // Option 2:
+        let mut font_description: FontDescription = FontDescription::default();
+        self.pango_context
+            .font_map()
+            .unwrap()
+            .load_fontset(&Context::default(), &font, &Language::default())
+            .unwrap()
+            .foreach(|_fontset, font| {
+                font_description = font.describe().unwrap();
+                true
+            });
+        println!("{:?}", font_description.to_string());
+        Some(FontFamily::new_unchecked(font_description.to_string()))
+
+        // Option 3:
+        // let target_lowercase = family_name.to_lowercase();
+        // let best_match = self
+        //     .pango_context
+        //     .list_families()
+        //     .first()
+        //     .map(|fontfam| fontfam.list_faces().first().unwrap().describe().unwrap())
+        //     .map(|font_desc| (font_desc.to_str(), font_desc))
+        //     .iter()
+        //     .cloned()
+        //     .chain(
+        //         self.pango_context
+        //             .list_families()
+        //             .iter()
+        //             .filter(|family| {
+        //                 let family_lowercase = family.name().unwrap().to_lowercase();
+        //                 family_lowercase.contains(target_lowercase.as_str())
+        //                     || target_lowercase.contains(family_lowercase.as_str())
+        //             })
+        //             .map(|family| {
+        //                 family
+        //                     .list_faces()
+        //                     .iter()
+        //                     .map(|fontface| {
+        //                         fontface
+        //                             .describe()
+        //                             .map(|fontdesc| (family.name().unwrap(), fontdesc))
+        //                     })
+        //                     .flatten()
+        //                     .collect::<Vec<(glib::GString, FontDescription)>>()
+        //             })
+        //             .flatten(),
+        //     )
+        //     .max_by(|a, b| {
+        //         //We can only use `better_match` with 2 args if the first argument matches matches
+        //         if font.better_match(None, &a.1) {
+        //             if font.better_match(Some(&a.1), &b.1) {
+        //                 println!("{:?}>{:?}", a.1.to_str(), b.1.to_str());
+        //                 Ordering::Greater
+        //             } else {
+        //                 println!("{:?}<{:?}", a.1.to_str(), b.1.to_str());
+        //                 Ordering::Less
+        //             }
+        //         } else if font.better_match(None, &b.1) {
+        //             println!("{:?}<<{:?}", a.1.to_str(), b.1.to_str());
+        //             Ordering::Greater
+        //         } else {
+        //             println!("{:?}={:?}", a.1.to_str(), b.1.to_str());
+        //             Ordering::Equal
+        //         }
+        //     });
+        // println!(
+        //     "{:?}",
+        //     self.pango_context.font_description().unwrap().to_str()
+        // );
+        // println!("{:?}", family_name);
+        // println!("{:?}", best_match);
+
+        // best_match.map(|(family, _)| {
+        //     println!("{:?}", family);
+        //     FontFamily::new_unchecked(family_name)
+        // })
+        // itemize_state_init
     }
 
     fn load_font(&mut self, _data: &[u8]) -> Result<FontFamily, Error> {
@@ -332,14 +447,30 @@ impl TextLayoutBuilder for CairoTextLayoutBuilder {
             }
             .into_pango(),
         );
-
-        for attribute in self.attributes {
-            pango_attributes.insert(attribute.into_pango());
+        for attr in pango_attributes.iterator().unwrap().attrs() {
+            println!("attr:{:?}", attr.type_());
         }
 
+        for attribute in &self.attributes {
+            if let TextAttribute::FontFamily(fam) = &attribute.attribute {
+                println!("{:?}", fam);
+                pango_attributes.insert(
+                    AttributeWithRange {
+                        attribute: TextAttribute::FontFamily(fam.clone()),
+                        range: None,
+                    }
+                    .into_pango(),
+                );
+            }
+        }
+        for attr in pango_attributes.iterator().unwrap().attrs() {
+            println!("attr:{:?}", attr.type_());
+        }
+        println!("1:{:?}", self.pango_layout.font_description());
         self.pango_layout.set_attributes(Some(&pango_attributes));
         self.pango_layout.set_wrap(pango::WrapMode::WordChar);
         self.pango_layout.set_ellipsize(pango::EllipsizeMode::None);
+        println!("2:{:?}", self.pango_layout.font_description());
 
         // invalid until update_width() is called
         let mut layout = CairoTextLayout {

piet/src/font.rs

@@ -84,7 +84,7 @@ impl FontFamily {
             FontFamilyInner::SansSerif => "sans-serif",
             FontFamilyInner::SystemUi => "system-ui",
             FontFamilyInner::Monospace => "monospace",
-            FontFamilyInner::Named(s) => &s,
+            FontFamilyInner::Named(s) => s,
         }
     }