Vi-style editor and other editor improvements (#40)

* WIP VI wrapper for editor

* WIP: block cursor

* Create Edit trait, run CI on all feature options

* Add prints describing build steps to ci.sh

* Custom rendering for Vi editor

* Clippy fixes

* More clippy fixes

* Show clippy results in CI

* Fix for Redox

* Fix clippy lint

* Add vi feature to enable vi-style editor

* Add escape to libcosmic text box

src/font/fallback/macos.rs

@@ -36,7 +36,7 @@ fn han_unification(locale: &str) -> &'static [&'static str] {
 }
 
 // Fallbacks to use per script
-pub fn script_fallback(script: &Script, locale: &str) -> &'static [&'static str] {
+pub fn script_fallback(script: Script, locale: &str) -> &'static [&'static str] {
     //TODO: abstract style (sans/serif/monospaced)
     //TODO: pull more data from about:config font.name-list.sans-serif in Firefox
     match script {

src/font/fallback/mod.rs

@@ -108,7 +108,7 @@ impl<'a> Iterator for FontFallbackIter<'a> {
         while self.script_i.0 < self.scripts.len() {
             let script = self.scripts[self.script_i.0];
 
-            let script_families = script_fallback(&script, self.locale);
+            let script_families = script_fallback(script, self.locale);
             while self.script_i.1 < script_families.len() {
                 let script_family = script_families[self.script_i.1];
                 self.script_i.1 += 1;
@@ -133,7 +133,7 @@ impl<'a> Iterator for FontFallbackIter<'a> {
                     return Some(font);
                 }
             }
-            log::warn!("failed to find family '{}'", common_family)
+            log::warn!("failed to find family '{}'", common_family);
         }
 
         //TODO: do we need to do this?

src/font/fallback/other.rs

@@ -13,6 +13,6 @@ pub fn forbidden_fallback() -> &'static [&'static str] {
 }
 
 // Fallbacks to use per script
-pub fn script_fallback(script: &Script, locale: &str) -> &'static [&'static str] {
+pub fn script_fallback(_script: Script, _locale: &str) -> &'static [&'static str] {
     &[]
 }

src/font/fallback/unix.rs

@@ -44,7 +44,7 @@ fn han_unification(locale: &str) -> &'static [&'static str] {
 }
 
 // Fallbacks to use per script
-pub fn script_fallback(script: &Script, locale: &str) -> &'static [&'static str] {
+pub fn script_fallback(script: Script, locale: &str) -> &'static [&'static str] {
     //TODO: abstract style (sans/serif/monospaced)
     match script {
         Script::Adlam => &["Noto Sans Adlam", "Noto Sans Adlam Unjoined"],

src/font/fallback/windows.rs

@@ -36,7 +36,7 @@ fn han_unification(locale: &str) -> &'static [&'static str] {
 }
 
 // Fallbacks to use per script
-pub fn script_fallback(script: &Script, locale: &str) -> &'static [&'static str] {
+pub fn script_fallback(script: Script, locale: &str) -> &'static [&'static str] {
     //TODO: better match https://github.com/chromium/chromium/blob/master/third_party/blink/renderer/platform/fonts/win/font_fallback_win.cc#L99
     match script {
         Script::Adlam => &["Ebrima"],

src/font/font.rs

@@ -1,46 +0,0 @@
-// SPDX-License-Identifier: MIT OR Apache-2.0
-
-use core::ops::Deref;
-
-pub struct Font<'a> {
-    pub info: &'a fontdb::FaceInfo,
-    pub data: &'a [u8],
-    pub rustybuzz: rustybuzz::Face<'a>,
-    #[cfg(feature = "swash")]
-    pub swash: (u32, swash::CacheKey),
-}
-
-impl<'a> Font<'a> {
-    pub fn new(info: &'a fontdb::FaceInfo) -> Option<Self> {
-        let data = match &info.source {
-            fontdb::Source::Binary(data) => data.deref().as_ref(),
-            #[cfg(feature = "std")]
-            fontdb::Source::File(path) => {
-                log::warn!("Unsupported fontdb Source::File('{}')", path.display());
-                return None;
-            }
-            #[cfg(feature = "std")]
-            fontdb::Source::SharedFile(_path, data) => data.deref().as_ref(),
-        };
-
-        Some(Self {
-            info,
-            data,
-            rustybuzz: rustybuzz::Face::from_slice(data, info.index)?,
-            #[cfg(feature = "swash")]
-            swash: {
-                let swash = swash::FontRef::from_index(data, info.index as usize)?;
-                (swash.offset, swash.key)
-            },
-        })
-    }
-
-    #[cfg(feature = "swash")]
-    pub fn as_swash(&self) -> swash::FontRef {
-        swash::FontRef {
-            data: self.data,
-            offset: self.swash.0,
-            key: self.swash.1,
-        }
-    }
-}

src/font/mod.rs

@@ -1,12 +1,54 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-pub(crate) mod fallback;
+use core::ops::Deref;
 
-pub(crate) use self::font::*;
-mod font;
+pub(crate) mod fallback;
 
 pub use self::matches::*;
 mod matches;
 
 pub use self::system::*;
 mod system;
+
+pub struct Font<'a> {
+    pub info: &'a fontdb::FaceInfo,
+    pub data: &'a [u8],
+    pub rustybuzz: rustybuzz::Face<'a>,
+    #[cfg(feature = "swash")]
+    pub swash: (u32, swash::CacheKey),
+}
+
+impl<'a> Font<'a> {
+    pub fn new(info: &'a fontdb::FaceInfo) -> Option<Self> {
+        let data = match &info.source {
+            fontdb::Source::Binary(data) => data.deref().as_ref(),
+            #[cfg(feature = "std")]
+            fontdb::Source::File(path) => {
+                log::warn!("Unsupported fontdb Source::File('{}')", path.display());
+                return None;
+            }
+            #[cfg(feature = "std")]
+            fontdb::Source::SharedFile(_path, data) => data.deref().as_ref(),
+        };
+
+        Some(Self {
+            info,
+            data,
+            rustybuzz: rustybuzz::Face::from_slice(data, info.index)?,
+            #[cfg(feature = "swash")]
+            swash: {
+                let swash = swash::FontRef::from_index(data, info.index as usize)?;
+                (swash.offset, swash.key)
+            },
+        })
+    }
+
+    #[cfg(feature = "swash")]
+    pub fn as_swash(&self) -> swash::FontRef {
+        swash::FontRef {
+            data: self.data,
+            offset: self.swash.0,
+            key: self.swash.1,
+        }
+    }
+}

src/font/system/mod.rs

@@ -3,7 +3,13 @@ pub use self::no_std::*;
 #[cfg(not(feature = "std"))]
 mod no_std;
 
-#[cfg(feature = "std")]
+//TODO: use std implementation on Redox
+#[cfg(all(feature = "std", target_os = "redox"))]
+pub use self::redox::*;
+#[cfg(all(feature = "std", target_os = "redox"))]
+mod redox;
+
+#[cfg(all(feature = "std", not(target_os = "redox")))]
 pub use self::std::*;
-#[cfg(feature = "std")]
+#[cfg(all(feature = "std", not(target_os = "redox")))]
 mod std;

src/font/system/no_std.rs

@@ -42,6 +42,8 @@ impl FontSystem {
         &self.db
     }
 
+    // Clippy false positive
+    #[allow(clippy::needless_lifetimes)]
     pub fn get_font<'a>(&'a self, id: fontdb::ID) -> Option<Arc<Font<'a>>> {
         let face = self.db.face(id)?;
         match Font::new(face) {
@@ -60,9 +62,8 @@ impl FontSystem {
                 continue;
             }
 
-            match self.get_font(face.id) {
-                Some(font) => fonts.push(font),
-                None => (),
+            if let Some(font) = self.get_font(face.id) {
+                fonts.push(font);
             }
         }
 

src/font/system/redox.rs

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+use alloc::{
+    string::{String, ToString},
+    sync::Arc,
+    vec::Vec,
+};
+
+use crate::{Attrs, Font, FontMatches};
+
+/// Access system fonts
+pub struct FontSystem{
+    locale: String,
+    db: fontdb::Database,
+}
+
+impl FontSystem {
+    pub fn new() -> Self {
+        let locale = sys_locale::get_locale().unwrap_or_else(|| {
+            log::warn!("failed to get system locale, falling back to en-US");
+            String::from("en-US")
+        });
+        log::info!("Locale: {}", locale);
+
+        //TODO: allow loading fonts from memory
+        let mut db = fontdb::Database::new();
+        {
+            let now = std::time::Instant::now();
+
+            db.load_fonts_dir("/ui/fonts");
+            //TODO: configurable default fonts
+            db.set_monospace_family("Fira Mono");
+            db.set_sans_serif_family("Fira Sans");
+            db.set_serif_family("DejaVu Serif");
+
+            log::info!(
+                "Parsed {} font faces in {}ms.",
+                db.len(),
+                now.elapsed().as_millis()
+            );
+        }
+
+        {
+            let now = std::time::Instant::now();
+
+            //TODO only do this on demand!
+            for i in 0..db.faces().len() {
+                let id = db.faces()[i].id;
+                unsafe { db.make_shared_face_data(id); }
+            }
+
+            log::info!(
+                "Mapped {} font faces in {}ms.",
+                db.len(),
+                now.elapsed().as_millis()
+            );
+        }
+
+        Self {
+            locale,
+            db,
+        }
+    }
+
+    pub fn locale(&self) -> &str {
+        &self.locale
+    }
+
+    pub fn db(&self) -> &fontdb::Database {
+        &self.db
+    }
+
+    // Clippy false positive
+    #[allow(clippy::needless_lifetimes)]
+    pub fn get_font<'a>(&'a self, id: fontdb::ID) -> Option<Arc<Font<'a>>> {
+        let face = self.db.face(id)?;
+        match Font::new(face) {
+            Some(font) => Some(Arc::new(font)),
+            None => {
+                log::warn!("failed to load font '{}'", face.post_script_name);
+                None
+            }
+        }
+    }
+
+    pub fn get_font_matches<'a>(&'a self, attrs: Attrs) -> Arc<FontMatches<'a>> {
+        let mut fonts = Vec::new();
+        for face in self.db.faces() {
+            if !attrs.matches(face) {
+                continue;
+            }
+
+            if let Some(font) = self.get_font(face.id) {
+                fonts.push(font);
+            }
+        }
+
+        Arc::new(FontMatches {
+            locale: &self.locale,
+            default_family: self.db.family_name(&attrs.family).to_string(),
+            fonts
+        })
+    }
+}

src/font/system/std.rs

@@ -23,6 +23,7 @@ struct FontSystemInner {
 pub struct FontSystem(FontSystemInner);
 
 impl FontSystem {
+    /// Create a new [`FontSystem`], that allows access to any installed system fonts
     pub fn new() -> Self {
         let locale = sys_locale::get_locale().unwrap_or_else(|| {
             log::warn!("failed to get system locale, falling back to en-US");
@@ -51,8 +52,7 @@ impl FontSystem {
             let now = std::time::Instant::now();
 
             //TODO only do this on demand!
-            assert_eq!(db.len(), db.faces().len());
-            for i in 0..db.len() {
+            for i in 0..db.faces().len() {
                 let id = db.faces()[i].id;
                 unsafe { db.make_shared_face_data(id); }
             }
@@ -80,6 +80,8 @@ impl FontSystem {
         self.0.borrow_db()
     }
 
+    // Clippy false positive
+    #[allow(clippy::needless_lifetimes)]
     pub fn get_font<'a>(&'a self, id: fontdb::ID) -> Option<Arc<Font<'a>>> {
         self.0.with(|fields| {
             get_font(&fields, id)
@@ -88,7 +90,7 @@ impl FontSystem {
 
     pub fn get_font_matches<'a>(&'a self, attrs: Attrs) -> Arc<FontMatches<'a>> {
         self.0.with(|fields| {
-            let mut font_matches_cache = fields.font_matches_cache.lock().unwrap();
+            let mut font_matches_cache = fields.font_matches_cache.lock().expect("failed to lock font matches cache");
             //TODO: do not create AttrsOwned unless entry does not already exist
             font_matches_cache.entry(AttrsOwned::new(attrs)).or_insert_with(|| {
                 let now = std::time::Instant::now();
@@ -99,9 +101,8 @@ impl FontSystem {
                         continue;
                     }
 
-                    match get_font(&fields, face.id) {
-                        Some(font) => fonts.push(font),
-                        None => (),
+                    if let Some(font) = get_font(&fields, face.id) {
+                        fonts.push(font);
                     }
                 }
 
@@ -121,7 +122,7 @@ impl FontSystem {
 }
 
 fn get_font<'b>(fields: &ouroboros_impl_font_system_inner::BorrowedFields<'_, 'b>, id: fontdb::ID) -> Option<Arc<Font<'b>>> {
-    fields.font_cache.lock().unwrap().entry(id).or_insert_with(|| {
+    fields.font_cache.lock().expect("failed to lock font cache").entry(id).or_insert_with(|| {
         let face = fields.db.face(id)?;
         match Font::new(face) {
             Some(font) => Some(Arc::new(font)),