Style people panel

Co-Authored-By: Nathan Sobo <nathan@zed.dev>

gpui/src/color.rs

@@ -33,6 +33,14 @@ impl Color {
         Self(ColorU::from_u32(0xff0000ff))
     }
 
+    pub fn green() -> Self {
+        Self(ColorU::from_u32(0x00ff00ff))
+    }
+
+    pub fn blue() -> Self {
+        Self(ColorU::from_u32(0x0000ffff))
+    }
+
     pub fn new(r: u8, g: u8, b: u8, a: u8) -> Self {
         Self(ColorU::new(r, g, b, a))
     }

gpui/src/elements.rs

@@ -8,7 +8,6 @@ mod flex;
 mod hook;
 mod image;
 mod label;
-mod line_box;
 mod list;
 mod mouse_event_handler;
 mod overlay;
@@ -19,8 +18,8 @@ mod uniform_list;
 
 pub use self::{
     align::*, canvas::*, constrained_box::*, container::*, empty::*, event_handler::*, flex::*,
-    hook::*, image::*, label::*, line_box::*, list::*, mouse_event_handler::*, overlay::*,
-    stack::*, svg::*, text::*, uniform_list::*,
+    hook::*, image::*, label::*, list::*, mouse_event_handler::*, overlay::*, stack::*, svg::*,
+    text::*, uniform_list::*,
 };
 pub use crate::presenter::ChildView;
 use crate::{

gpui/src/elements/label.rs

@@ -137,8 +137,7 @@ impl Element for Label {
         let size = vec2f(
             line.width().max(constraint.min.x()).min(constraint.max.x()),
             cx.font_cache
-                .line_height(self.style.text.font_id, self.style.text.font_size)
-                .ceil(),
+                .line_height(self.style.text.font_id, self.style.text.font_size),
         );
 
         (size, line)

gpui/src/elements/line_box.rs

@@ -1,87 +0,0 @@
-use crate::{
-    fonts::TextStyle,
-    geometry::{
-        rect::RectF,
-        vector::{vec2f, Vector2F},
-    },
-    json::{json, ToJson},
-    DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
-    SizeConstraint,
-};
-
-pub struct LineBox {
-    child: ElementBox,
-    style: TextStyle,
-}
-
-impl LineBox {
-    pub fn new(child: ElementBox, style: TextStyle) -> Self {
-        Self { child, style }
-    }
-}
-
-impl Element for LineBox {
-    type LayoutState = f32;
-    type PaintState = ();
-
-    fn layout(
-        &mut self,
-        constraint: SizeConstraint,
-        cx: &mut LayoutContext,
-    ) -> (Vector2F, Self::LayoutState) {
-        let line_height = cx
-            .font_cache
-            .line_height(self.style.font_id, self.style.font_size);
-        let character_height = cx
-            .font_cache
-            .ascent(self.style.font_id, self.style.font_size)
-            + cx.font_cache
-                .descent(self.style.font_id, self.style.font_size);
-        let child_max = vec2f(constraint.max.x(), character_height);
-        let child_size = self.child.layout(
-            SizeConstraint::new(constraint.min.min(child_max), child_max),
-            cx,
-        );
-        let size = vec2f(child_size.x(), line_height);
-        (size, (line_height - character_height) / 2.)
-    }
-
-    fn paint(
-        &mut self,
-        bounds: RectF,
-        visible_bounds: RectF,
-        padding_top: &mut f32,
-        cx: &mut PaintContext,
-    ) -> Self::PaintState {
-        self.child.paint(
-            bounds.origin() + vec2f(0., *padding_top),
-            visible_bounds,
-            cx,
-        );
-    }
-
-    fn dispatch_event(
-        &mut self,
-        event: &Event,
-        _: RectF,
-        _: &mut Self::LayoutState,
-        _: &mut Self::PaintState,
-        cx: &mut EventContext,
-    ) -> bool {
-        self.child.dispatch_event(event, cx)
-    }
-
-    fn debug(
-        &self,
-        bounds: RectF,
-        _: &Self::LayoutState,
-        _: &Self::PaintState,
-        cx: &DebugContext,
-    ) -> serde_json::Value {
-        json!({
-            "bounds": bounds.to_json(),
-            "style": self.style.to_json(),
-            "child": self.child.debug(cx),
-        })
-    }
-}

gpui/src/font_cache.rs

@@ -166,6 +166,10 @@ impl FontCache {
         self.metric(font_id, |m| m.cap_height) * self.em_scale(font_id, font_size)
     }
 
+    pub fn x_height(&self, font_id: FontId, font_size: f32) -> f32 {
+        self.metric(font_id, |m| m.x_height) * self.em_scale(font_id, font_size)
+    }
+
     pub fn ascent(&self, font_id: FontId, font_size: f32) -> f32 {
         self.metric(font_id, |m| m.ascent) * self.em_scale(font_id, font_size)
     }
@@ -178,6 +182,14 @@ impl FontCache {
         font_size / self.metric(font_id, |m| m.units_per_em as f32)
     }
 
+    pub fn baseline_offset(&self, font_id: FontId, font_size: f32) -> f32 {
+        let line_height = self.line_height(font_id, font_size);
+        let ascent = self.ascent(font_id, font_size);
+        let descent = self.descent(font_id, font_size);
+        let padding_top = (line_height - ascent - descent) / 2.;
+        padding_top + ascent
+    }
+
     pub fn line_wrapper(self: &Arc<Self>, font_id: FontId, font_size: f32) -> LineWrapperHandle {
         let mut state = self.0.write();
         let wrappers = state

gpui/src/fonts.rs

@@ -132,6 +132,14 @@ impl TextStyle {
         font_cache.line_height(self.font_id, self.font_size)
     }
 
+    pub fn cap_height(&self, font_cache: &FontCache) -> f32 {
+        font_cache.cap_height(self.font_id, self.font_size)
+    }
+
+    pub fn x_height(&self, font_cache: &FontCache) -> f32 {
+        font_cache.x_height(self.font_id, self.font_size)
+    }
+
     pub fn em_width(&self, font_cache: &FontCache) -> f32 {
         font_cache.em_width(self.font_id, self.font_size)
     }
@@ -140,6 +148,10 @@ impl TextStyle {
         font_cache.metric(self.font_id, |m| m.descent) * self.em_scale(font_cache)
     }
 
+    pub fn baseline_offset(&self, font_cache: &FontCache) -> f32 {
+        font_cache.baseline_offset(self.font_id, self.font_size)
+    }
+
     fn em_scale(&self, font_cache: &FontCache) -> f32 {
         font_cache.em_scale(self.font_id, self.font_size)
     }