Fixed several issues found in examples

The containers example has slowed down at some point. Some very basic
benchmarking pointed to the font family list being applied being
expensive. I attempted to reduce the overhead of this by making single
element lists be allocation free. Unfortunately that wasn't enough, and
this slowdown is almost certainly unrelated to this branch, so while I'm
keeping the optimization, the example is still too slow.

In the process of trying to get baseline working for the Grid widget, at
one point I changed the "other" constraint to SizeToFit to prevent
labels from growing. Ultimately, the label code itself was updated to
account for this. By changing this back, many examples were working
correctly again.

Lastly, the selection rectangle for a single line of text wasn't
including the descender... which then became more complex since that
measurement isn't present if the text doesn't have any descenders.
There's an approximation in place now, but I suspect we should measure a
character with a descender to get the line metrics.

Author: ecton

examples/7guis-counter.rs

@@ -9,6 +9,7 @@ fn main() -> cushy::Result {
 
     count
         .to_label()
+        .centered()
         .expand()
         .and(
             "Count"

examples/buttons.rs

@@ -16,6 +16,7 @@ fn main() -> cushy::Result {
 
     clicked_label
         .clone()
+        .centered()
         .and(
             "Normal Button"
                 .into_button()

examples/fonts-dynamic.rs

@@ -27,9 +27,9 @@ fn main() -> cushy::Result<()> {
             let font = loaded_font.get_tracking_invalidate(context)?;
 
             let face = context.loaded_font_faces(&font).first()?;
-            Some(Component::custom(FontFamilyList::from(vec![
-                FamilyOwned::Name(face.families[0].0.clone()),
-            ])))
+            Some(Component::custom(FontFamilyList::from(FamilyOwned::Name(
+                face.families[0].0.clone(),
+            ))))
         }
     });
     let family_weight = DynamicComponent::new(move |context| {

examples/scroll-nested.rs

@@ -1,19 +1,19 @@
 use cushy::figures::units::Lp;
 use cushy::kludgine::cosmic_text::FamilyOwned;
 use cushy::styles::components::FontFamily;
-use cushy::styles::{Edges, FontFamilyList};
+use cushy::styles::Edges;
 use cushy::widget::MakeWidget;
 use cushy::Run;
 
 fn main() -> cushy::Result {
     include_str!("scroll-nested.rs")
         .vertical_scroll()
-        .with(&FontFamily, FontFamilyList::from(FamilyOwned::Monospace))
+        .with(&FontFamily, FamilyOwned::Monospace)
         .height(Lp::inches(3))
         .and(
             include_str!("./canvas.rs")
                 .vertical_scroll()
-                .with(&FontFamily, FontFamilyList::from(FamilyOwned::Monospace))
+                .with(&FontFamily, FamilyOwned::Monospace)
                 .height(Lp::inches(3)),
         )
         .into_rows()

src/context.rs

@@ -625,7 +625,7 @@ impl<'clip, 'gfx, 'pass> GraphicsContext<'_, 'clip, 'gfx, 'pass> {
         self.font_state
             .current_font_family
             .clone()
-            .unwrap_or_else(|| FontFamilyList::from(vec![FamilyOwned::new(self.gfx.font_family())]))
+            .unwrap_or_else(|| FontFamilyList::from(FamilyOwned::new(self.gfx.font_family())))
     }
 
     /// Returns the first font family in `list` that is currently in the font

src/styles.rs

@@ -9,6 +9,7 @@ use std::ops::{
     RangeToInclusive, Sub,
 };
 use std::sync::Arc;
+use std::{mem, slice};
 
 use ahash::AHashMap;
 use figures::units::{Lp, Px, UPx};
@@ -2698,47 +2699,82 @@ impl From<ColorSource> for ColorScheme {
     }
 }
 
-/// A list of font families.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct FontFamilyList(Arc<Vec<FamilyOwned>>);
-
-impl Default for FontFamilyList {
-    fn default() -> Self {
-        static DEFAULT: Lazy<FontFamilyList> = Lazy::new(|| FontFamilyList::from(vec![]));
-        DEFAULT.clone()
-    }
+enum FontFamilyListData {
+    Single(FamilyOwned),
+    Multiple(Arc<Vec<FamilyOwned>>),
 }
 
+/// A list of font families.
+#[derive(Clone, Debug, Eq, PartialEq, Default)]
+pub struct FontFamilyList(Option<FontFamilyListData>);
+
 impl FontFamilyList {
     /// Pushes `family` on the end of this list.
     pub fn push(&mut self, family: FamilyOwned) {
-        Arc::make_mut(&mut self.0).push(family);
+        match &mut self.0 {
+            None => {
+                self.0 = Some(FontFamilyListData::Single(family));
+            }
+            Some(FontFamilyListData::Single(first_family)) => {
+                let first_family = mem::replace(first_family, FamilyOwned::Serif);
+                self.0 = Some(FontFamilyListData::Multiple(Arc::new(vec![
+                    first_family,
+                    family,
+                ])));
+            }
+            Some(FontFamilyListData::Multiple(vec)) => {
+                Arc::make_mut(vec).push(family);
+            }
+        }
     }
 }
 
 impl Deref for FontFamilyList {
     type Target = [FamilyOwned];
 
     fn deref(&self) -> &Self::Target {
-        &self.0
+        match &self.0 {
+            Some(FontFamilyListData::Single(family)) => slice::from_ref(family),
+            Some(FontFamilyListData::Multiple(vec)) => vec,
+            None => &[],
+        }
     }
 }
 
 impl FromIterator<FamilyOwned> for FontFamilyList {
     fn from_iter<T: IntoIterator<Item = FamilyOwned>>(iter: T) -> Self {
-        Self(Arc::new(iter.into_iter().collect()))
+        let mut iter = iter.into_iter();
+        match iter.size_hint().0 {
+            0 | 1 => match iter.next() {
+                Some(first) => match iter.next() {
+                    Some(second) => {
+                        let mut contents = vec![first, second];
+                        contents.extend(iter);
+                        Self(Some(FontFamilyListData::Multiple(Arc::new(contents))))
+                    }
+                    None => Self(Some(FontFamilyListData::Single(first))),
+                },
+                None => Self(None),
+            },
+            _ => Self(Some(FontFamilyListData::Multiple(Arc::new(iter.collect())))),
+        }
     }
 }
 
 impl From<FamilyOwned> for FontFamilyList {
     fn from(value: FamilyOwned) -> Self {
-        Self::from(vec![value])
+        Self(Some(FontFamilyListData::Single(value)))
     }
 }
 
 impl From<Vec<FamilyOwned>> for FontFamilyList {
     fn from(value: Vec<FamilyOwned>) -> Self {
-        Self(Arc::new(value))
+        match value.len() {
+            1 => Self(value.into_iter().next().map(FontFamilyListData::Single)),
+            0 => Self(None),
+            _ => Self(Some(FontFamilyListData::Multiple(Arc::new(value)))),
+        }
     }
 }
 

src/widgets/grid.rs

@@ -634,7 +634,7 @@ impl GridLayout {
                             element,
                             self.orientation.make_size(
                                 ConstraintLimit::Fill(self.layouts[index].size.into_upx(scale)),
-                                ConstraintLimit::SizeToFit(self.others[element]),
+                                ConstraintLimit::Fill(self.others[element]),
                             ),
                             true,
                         );

src/widgets/input.rs

@@ -1072,6 +1072,14 @@ where
             });
         }
 
+        // TODO: Approximating the descent is not great. We probably should
+        // measure a letter with a descender and use that size as a minimum.
+        let full_line_height = info.cache.measured.line_height
+            - info
+                .cache
+                .measured
+                .descent
+                .min((-info.cache.measured.line_height / 3).ceil());
         if let Some(selection) = info.selection {
             let (start, end) = if selection < info.cursor {
                 (selection, info.cursor)
@@ -1088,10 +1096,7 @@ where
                 let width = end_position.x - start_position.x;
                 context.gfx.draw_shape(
                     Shape::filled_rect(
-                        Rect::new(
-                            start_position,
-                            Size::new(width, info.cache.measured.line_height),
-                        ),
+                        Rect::new(start_position, Size::new(width, full_line_height)),
                         highlight,
                     )
                     .translate_by(padding),
@@ -1101,16 +1106,13 @@ where
                 let width = size.width.into_signed() - start_position.x;
                 context.gfx.draw_shape(
                     Shape::filled_rect(
-                        Rect::new(
-                            start_position,
-                            Size::new(width, info.cache.measured.line_height),
-                        ),
+                        Rect::new(start_position, Size::new(width, full_line_height)),
                         highlight,
                     )
                     .translate_by(padding),
                 );
                 // Fill region between
-                let bottom_of_first_line = start_position.y + info.cache.measured.line_height;
+                let bottom_of_first_line = start_position.y + full_line_height;
                 let distance_between = end_position.y - bottom_of_first_line;
                 if distance_between > 0 {
                     context.gfx.draw_shape(
@@ -1129,7 +1131,7 @@ where
                     Shape::filled_rect(
                         Rect::new(
                             Point::new(Px::ZERO, end_position.y),
-                            Size::new(end_position.x + end_width, info.cache.measured.line_height),
+                            Size::new(end_position.x + end_width, full_line_height),
                         ),
                         highlight,
                     )
@@ -1144,7 +1146,7 @@ where
                     Shape::filled_rect(
                         Rect::new(
                             Point::new(location.x - cursor_width / 2, location.y),
-                            Size::new(cursor_width, info.cache.measured.line_height),
+                            Size::new(cursor_width, full_line_height),
                         ),
                         highlight,
                     )
@@ -1189,7 +1191,7 @@ where
 
         WidgetLayout {
             size: available_space.fit_measured(measured_size),
-            baseline: Baseline::from(padding + info.cache.measured.ascent.into_unsigned()),
+            baseline: Baseline::from(padding + info.cache.measured.line_height.into_unsigned()),
         }
     }