151 lines
4.1 KiB
Rust
151 lines
4.1 KiB
Rust
use crate::{
|
|
element::{Element, IntoElement, Layout},
|
|
layout_context::LayoutContext,
|
|
paint_context::PaintContext,
|
|
};
|
|
use anyhow::Result;
|
|
use gpui::text_layout::LineLayout;
|
|
use parking_lot::Mutex;
|
|
use std::sync::Arc;
|
|
|
|
impl<V: 'static, S: Into<ArcCow<'static, str>>> IntoElement<V> for S {
|
|
type Element = Text;
|
|
|
|
fn into_element(self) -> Self::Element {
|
|
Text { text: self.into() }
|
|
}
|
|
}
|
|
|
|
pub struct Text {
|
|
text: ArcCow<'static, str>,
|
|
}
|
|
|
|
impl<V: 'static> Element<V> for Text {
|
|
type Layout = Arc<Mutex<Option<TextLayout>>>;
|
|
|
|
fn layout(
|
|
&mut self,
|
|
view: &mut V,
|
|
cx: &mut LayoutContext<V>,
|
|
) -> Result<Layout<V, Self::Layout>> {
|
|
// let rem_size = cx.rem_pixels();
|
|
// let fonts = cx.platform().fonts();
|
|
// let text_style = cx.text_style();
|
|
// let line_height = cx.font_cache().line_height(text_style.font_size);
|
|
// let layout_engine = cx.layout_engine().expect("no layout engine present");
|
|
// let text = self.text.clone();
|
|
// let layout = Arc::new(Mutex::new(None));
|
|
|
|
// let style: Style = Style::default().refined(&self.metadata.style);
|
|
// let node_id = layout_engine.add_measured_node(style.to_taffy(rem_size), {
|
|
// let layout = layout.clone();
|
|
// move |params| {
|
|
// let line_layout = fonts.layout_line(
|
|
// text.as_ref(),
|
|
// text_style.font_size,
|
|
// &[(text.len(), text_style.to_run())],
|
|
// );
|
|
|
|
// let size = Size {
|
|
// width: line_layout.width,
|
|
// height: line_height,
|
|
// };
|
|
|
|
// layout.lock().replace(TextLayout {
|
|
// line_layout: Arc::new(line_layout),
|
|
// line_height,
|
|
// });
|
|
|
|
// size
|
|
// }
|
|
// })?;
|
|
|
|
// Ok((node_id, layout))
|
|
todo!()
|
|
}
|
|
|
|
fn paint<'a>(
|
|
&mut self,
|
|
view: &mut V,
|
|
layout: &mut Layout<V, Self::Layout>,
|
|
cx: &mut PaintContext<V>,
|
|
) {
|
|
// ) {
|
|
// let element_layout_lock = layout.from_element.lock();
|
|
// let element_layout = element_layout_lock
|
|
// .as_ref()
|
|
// .expect("layout has not been performed");
|
|
// let line_layout = element_layout.line_layout.clone();
|
|
// let line_height = element_layout.line_height;
|
|
// drop(element_layout_lock);
|
|
|
|
// let text_style = cx.text_style();
|
|
// let line =
|
|
// gpui::text_layout::Line::new(line_layout, &[(self.text.len(), text_style.to_run())]);
|
|
// line.paint(
|
|
// cx.scene,
|
|
// layout.from_engine.bounds.origin(),
|
|
// layout.from_engine.bounds,
|
|
// line_height,
|
|
// cx.legacy_cx,
|
|
// );
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
pub struct TextLayout {
|
|
line_layout: Arc<LineLayout>,
|
|
line_height: f32,
|
|
}
|
|
|
|
pub enum ArcCow<'a, T: ?Sized> {
|
|
Borrowed(&'a T),
|
|
Owned(Arc<T>),
|
|
}
|
|
|
|
impl<'a, T: ?Sized> Clone for ArcCow<'a, T> {
|
|
fn clone(&self) -> Self {
|
|
match self {
|
|
Self::Borrowed(borrowed) => Self::Borrowed(borrowed),
|
|
Self::Owned(owned) => Self::Owned(owned.clone()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, T: ?Sized> From<&'a T> for ArcCow<'a, T> {
|
|
fn from(s: &'a T) -> Self {
|
|
Self::Borrowed(s)
|
|
}
|
|
}
|
|
|
|
impl<T> From<Arc<T>> for ArcCow<'_, T> {
|
|
fn from(s: Arc<T>) -> Self {
|
|
Self::Owned(s)
|
|
}
|
|
}
|
|
|
|
impl From<String> for ArcCow<'_, str> {
|
|
fn from(value: String) -> Self {
|
|
Self::Owned(value.into())
|
|
}
|
|
}
|
|
|
|
impl<T: ?Sized> std::ops::Deref for ArcCow<'_, T> {
|
|
type Target = T;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
match self {
|
|
ArcCow::Borrowed(s) => s,
|
|
ArcCow::Owned(s) => s.as_ref(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: ?Sized> AsRef<T> for ArcCow<'_, T> {
|
|
fn as_ref(&self) -> &T {
|
|
match self {
|
|
ArcCow::Borrowed(borrowed) => borrowed,
|
|
ArcCow::Owned(owned) => owned.as_ref(),
|
|
}
|
|
}
|
|
}
|