1546 lines
44 KiB
Rust
1546 lines
44 KiB
Rust
#![allow(unused_variables, dead_code)]
|
|
|
|
use derive_more::{Add, Deref, DerefMut};
|
|
use gpui::elements::layout_highlighted_chunks;
|
|
use gpui::Entity;
|
|
use gpui::{
|
|
color::Color,
|
|
fonts::HighlightStyle,
|
|
geometry::{
|
|
rect::RectF,
|
|
vector::{vec2f, Vector2F},
|
|
},
|
|
json::{json, ToJson},
|
|
scene,
|
|
serde_json::Value,
|
|
text_layout::{Line, ShapedBoundary},
|
|
AnyElement, AppContext, Element, LayoutContext, PaintContext, Quad, SceneBuilder,
|
|
SizeConstraint, View, ViewContext,
|
|
};
|
|
use length::{Length, Rems};
|
|
use log::warn;
|
|
use optional_struct::*;
|
|
use std::{any::Any, borrow::Cow, f32, ops::Range, sync::Arc};
|
|
|
|
use crate::color::Rgba;
|
|
|
|
pub struct Node<V: View> {
|
|
style: NodeStyle,
|
|
children: Vec<AnyElement<V>>,
|
|
id: Option<Cow<'static, str>>,
|
|
}
|
|
|
|
pub fn column<V: View>() -> Node<V> {
|
|
Node::default()
|
|
}
|
|
|
|
pub fn row<V: View>() -> Node<V> {
|
|
Node {
|
|
style: NodeStyle {
|
|
axis: Axis3d::X,
|
|
..Default::default()
|
|
},
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
pub fn stack<V: View>() -> Node<V> {
|
|
Node {
|
|
style: NodeStyle {
|
|
axis: Axis3d::Z,
|
|
..Default::default()
|
|
},
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
impl<V: View> Default for Node<V> {
|
|
fn default() -> Self {
|
|
Self {
|
|
style: Default::default(),
|
|
children: Default::default(),
|
|
id: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<V: View> Element<V> for Node<V> {
|
|
type LayoutState = NodeLayout;
|
|
type PaintState = ();
|
|
|
|
fn layout(
|
|
&mut self,
|
|
constraint: SizeConstraint,
|
|
view: &mut V,
|
|
cx: &mut LayoutContext<V>,
|
|
) -> (Vector2F, Self::LayoutState) {
|
|
let layout = if let Some(axis) = self.style.axis.to_2d() {
|
|
self.layout_xy(axis, constraint, cx.rem_pixels(), view, cx)
|
|
} else {
|
|
todo!()
|
|
};
|
|
|
|
(layout.size.max(constraint.min), layout)
|
|
}
|
|
|
|
fn paint(
|
|
&mut self,
|
|
scene: &mut SceneBuilder,
|
|
bounds: RectF,
|
|
visible_bounds: RectF,
|
|
layout: &mut NodeLayout,
|
|
view: &mut V,
|
|
cx: &mut PaintContext<V>,
|
|
) -> Self::PaintState {
|
|
dbg!(self.id_string());
|
|
dbg!(bounds.origin(), bounds.size());
|
|
|
|
let bounds_center = dbg!(bounds.size()) / 2.;
|
|
let bounds_target = bounds_center + (bounds_center * self.style.align.0);
|
|
let layout_center = dbg!(layout.size) / 2.;
|
|
let layout_target = layout_center + layout_center * self.style.align.0;
|
|
let delta = bounds_target - layout_target;
|
|
|
|
let aligned_bounds = RectF::new(bounds.origin() + delta, layout.size);
|
|
dbg!(aligned_bounds.origin(), aligned_bounds.size());
|
|
let margined_bounds = RectF::from_points(
|
|
aligned_bounds.origin() + vec2f(layout.margins.left, layout.margins.top),
|
|
aligned_bounds.lower_right() - vec2f(layout.margins.right, layout.margins.bottom),
|
|
);
|
|
dbg!(margined_bounds.origin(), margined_bounds.size());
|
|
|
|
// Paint drop shadow
|
|
for shadow in &self.style.shadows {
|
|
scene.push_shadow(scene::Shadow {
|
|
bounds: margined_bounds + shadow.offset,
|
|
corner_radius: self.style.corner_radius,
|
|
sigma: shadow.blur,
|
|
color: shadow.color,
|
|
});
|
|
}
|
|
|
|
// // Paint cursor style
|
|
// if let Some(hit_bounds) = content_bounds.intersection(visible_bounds) {
|
|
// if let Some(style) = self.style.cursor {
|
|
// scene.push_cursor_region(CursorRegion {
|
|
// bounds: hit_bounds,
|
|
// style,
|
|
// });
|
|
// }
|
|
// }
|
|
|
|
// Render the background and/or the border.
|
|
let Fill::Color(fill_color) = self.style.fill;
|
|
let is_fill_visible = fill_color.a > 0.;
|
|
if is_fill_visible || self.style.borders.is_visible() {
|
|
scene.push_quad(Quad {
|
|
bounds: margined_bounds,
|
|
background: is_fill_visible.then_some(fill_color.into()),
|
|
border: scene::Border {
|
|
width: self.style.borders.width,
|
|
color: self.style.borders.color,
|
|
overlay: false,
|
|
top: self.style.borders.top,
|
|
right: self.style.borders.right,
|
|
bottom: self.style.borders.bottom,
|
|
left: self.style.borders.left,
|
|
},
|
|
corner_radius: self.style.corner_radius,
|
|
});
|
|
}
|
|
|
|
if !self.children.is_empty() {
|
|
// Account for padding first.
|
|
let borders = &self.style.borders;
|
|
let padded_bounds = RectF::from_points(
|
|
margined_bounds.origin()
|
|
+ vec2f(
|
|
borders.left_width() + layout.padding.left,
|
|
borders.top_width() + layout.padding.top,
|
|
),
|
|
margined_bounds.lower_right()
|
|
- vec2f(
|
|
layout.padding.right + borders.right_width(),
|
|
layout.padding.bottom + borders.bottom_width(),
|
|
),
|
|
);
|
|
|
|
if let Some(axis) = self.style.axis.to_2d() {
|
|
// let parent_size = padded_bounds.size();
|
|
let mut child_origin = padded_bounds.origin();
|
|
|
|
for child in &mut self.children {
|
|
child.paint(scene, child_origin, visible_bounds, view, cx);
|
|
|
|
// Advance along the primary axis by the size of this child
|
|
child_origin.set(axis, child_origin.get(axis) + child.size().get(axis));
|
|
}
|
|
} else {
|
|
todo!();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn rect_for_text_range(
|
|
&self,
|
|
range_utf16: Range<usize>,
|
|
_: RectF,
|
|
_: RectF,
|
|
_: &Self::LayoutState,
|
|
_: &Self::PaintState,
|
|
view: &V,
|
|
cx: &ViewContext<V>,
|
|
) -> Option<RectF> {
|
|
self.children
|
|
.iter()
|
|
.find_map(|child| child.rect_for_text_range(range_utf16.clone(), view, cx))
|
|
}
|
|
|
|
fn debug(
|
|
&self,
|
|
bounds: RectF,
|
|
_: &Self::LayoutState,
|
|
_: &Self::PaintState,
|
|
view: &V,
|
|
cx: &ViewContext<V>,
|
|
) -> Value {
|
|
json!({
|
|
"type": "Node",
|
|
"bounds": bounds.to_json(),
|
|
// TODO!
|
|
// "children": self.content.iter().map(|child| child.debug(view, cx)).collect::<Vec<Value>>()
|
|
})
|
|
}
|
|
|
|
fn metadata(&self) -> Option<&dyn Any> {
|
|
Some(&self.style)
|
|
}
|
|
}
|
|
|
|
impl<V: View> Node<V> {
|
|
pub fn id(mut self, id: impl Into<Cow<'static, str>>) -> Self {
|
|
self.id = Some(id.into());
|
|
self
|
|
}
|
|
|
|
pub fn child(mut self, child: impl Element<V>) -> Self {
|
|
self.children.push(child.into_any());
|
|
self
|
|
}
|
|
|
|
pub fn children<I, E>(mut self, children: I) -> Self
|
|
where
|
|
I: IntoIterator<Item = E>,
|
|
E: Element<V>,
|
|
{
|
|
self.children
|
|
.extend(children.into_iter().map(|child| child.into_any()));
|
|
self
|
|
}
|
|
|
|
pub fn width(mut self, width: impl Into<Length>) -> Self {
|
|
self.style.size.width = width.into();
|
|
self
|
|
}
|
|
|
|
pub fn height(mut self, height: impl Into<Length>) -> Self {
|
|
self.style.size.height = height.into();
|
|
self
|
|
}
|
|
|
|
pub fn fill(mut self, fill: impl Into<Fill>) -> Self {
|
|
self.style.fill = fill.into();
|
|
self
|
|
}
|
|
|
|
pub fn text_size(mut self, text_size: Rems) -> Self {
|
|
self.style.text.size = Some(text_size);
|
|
self
|
|
}
|
|
|
|
pub fn margins(mut self, margins: impl Into<Edges<Length>>) -> Self {
|
|
self.style.margins = margins.into();
|
|
self
|
|
}
|
|
|
|
pub fn margin_x(mut self, margin: impl Into<Length>) -> Self {
|
|
self.style.margins.set_x(margin.into());
|
|
self
|
|
}
|
|
|
|
pub fn margin_y(mut self, margin: impl Into<Length>) -> Self {
|
|
self.style.margins.set_y(margin.into());
|
|
self
|
|
}
|
|
|
|
pub fn margin_top(mut self, top: Length) -> Self {
|
|
self.style.margins.top = top;
|
|
self
|
|
}
|
|
|
|
pub fn margin_bottom(mut self, bottom: Length) -> Self {
|
|
self.style.margins.bottom = bottom;
|
|
self
|
|
}
|
|
|
|
pub fn margin_left(mut self, left: impl Into<Length>) -> Self {
|
|
self.style.margins.left = left.into();
|
|
self
|
|
}
|
|
|
|
pub fn margin_right(mut self, right: impl Into<Length>) -> Self {
|
|
self.style.margins.right = right.into();
|
|
self
|
|
}
|
|
|
|
pub fn align(mut self, alignment: f32) -> Self {
|
|
let cross_axis = self
|
|
.style
|
|
.axis
|
|
.to_2d()
|
|
.map(Axis2d::rotate)
|
|
.unwrap_or(Axis2d::Y);
|
|
self.style.align.set(cross_axis, alignment);
|
|
self
|
|
}
|
|
|
|
pub fn justify(mut self, alignment: f32) -> Self {
|
|
let axis = self.style.axis.to_2d().unwrap_or(Axis2d::X);
|
|
self.style.align.set(axis, alignment);
|
|
self
|
|
}
|
|
|
|
fn id_string(&self) -> String {
|
|
self.id.as_deref().unwrap_or("<anonymous>").to_string()
|
|
}
|
|
|
|
fn layout_xy(
|
|
&mut self,
|
|
primary_axis: Axis2d,
|
|
constraint: SizeConstraint,
|
|
rem_pixels: f32,
|
|
view: &mut V,
|
|
cx: &mut LayoutContext<V>,
|
|
) -> NodeLayout {
|
|
let cross_axis = primary_axis.rotate();
|
|
let total_flex = self.style.flex();
|
|
let mut layout = NodeLayout {
|
|
size: Default::default(),
|
|
padding: self.style.padding.fixed_pixels(rem_pixels),
|
|
margins: self.style.margins.fixed_pixels(rem_pixels),
|
|
borders: self.style.borders.edges(),
|
|
};
|
|
let fixed_padding_size = layout.padding.size();
|
|
let fixed_margin_size = layout.margins.size();
|
|
let borders_size = layout.borders.size();
|
|
let fixed_constraint = constraint - fixed_margin_size - borders_size - fixed_padding_size;
|
|
|
|
// Determine the child constraints in each dimension based on the styled size
|
|
let mut child_constraint = SizeConstraint::default();
|
|
for axis in [Axis2d::X, Axis2d::Y] {
|
|
let length = self.style.size.get(axis);
|
|
let content_length = match length {
|
|
Length::Hug => {
|
|
// Tell the children not to expand
|
|
0.
|
|
}
|
|
Length::Fixed(fixed_length) => {
|
|
// Tell the children to expand up to the fixed length minus the padding.
|
|
fixed_length.to_pixels(rem_pixels) - fixed_padding_size.get(axis)
|
|
}
|
|
Length::Auto { .. } => {
|
|
// Tell the children to expand to fill their share of the flex space in this node.
|
|
length.flex_pixels(
|
|
rem_pixels,
|
|
&mut total_flex.get(axis),
|
|
&mut fixed_constraint.max.get(axis),
|
|
)
|
|
}
|
|
};
|
|
child_constraint.max.set(axis, content_length);
|
|
if axis == cross_axis {
|
|
child_constraint.min.set(axis, content_length);
|
|
}
|
|
}
|
|
|
|
// Lay out inflexible children. Total up flex of flexible children for
|
|
// use in a second pass.
|
|
let mut remaining_length = child_constraint.max.get(primary_axis);
|
|
let mut remaining_flex = 0.;
|
|
let mut total_length = 0.;
|
|
let mut cross_axis_max: f32 = 0.;
|
|
|
|
for child in &mut self.children {
|
|
if let Some(child_flex) = child
|
|
.metadata::<NodeStyle>()
|
|
.map(|style| style.flex().get(primary_axis))
|
|
{
|
|
if child_flex > 0. {
|
|
remaining_flex += child_flex;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
let child_size = child.layout(child_constraint, view, cx);
|
|
let child_length = child_size.get(primary_axis);
|
|
remaining_length -= child_length;
|
|
total_length += child_length;
|
|
cross_axis_max = cross_axis_max.max(child_size.get(cross_axis));
|
|
}
|
|
|
|
// Distribute the remaining length among the flexible children.
|
|
for child in &mut self.children {
|
|
if let Some(child_flex) = child
|
|
.metadata::<NodeStyle>()
|
|
.map(|style| style.flex().get(primary_axis))
|
|
{
|
|
if child_flex > 0. {
|
|
let max_child_length = (child_flex / remaining_flex) * remaining_length;
|
|
child_constraint.max.set(primary_axis, max_child_length);
|
|
|
|
let child_size = child.layout(child_constraint, view, cx);
|
|
let child_length = child_size.get(primary_axis);
|
|
total_length += child_length;
|
|
remaining_length -= child_length;
|
|
remaining_flex -= child_flex;
|
|
cross_axis_max = cross_axis_max.max(child_size.get(cross_axis));
|
|
}
|
|
}
|
|
}
|
|
|
|
let content_size = match primary_axis {
|
|
Axis2d::X => vec2f(total_length, cross_axis_max),
|
|
Axis2d::Y => vec2f(cross_axis_max, total_length),
|
|
};
|
|
|
|
// Distribute remaining space to flexible padding and margins.
|
|
for axis in [Axis2d::X, Axis2d::Y] {
|
|
let length = self.style.size.get(axis);
|
|
match length {
|
|
Length::Hug => {
|
|
let mut remaining_flex = total_flex.get(axis);
|
|
let mut remaining_length =
|
|
fixed_constraint.min.get(axis) - content_size.get(axis);
|
|
|
|
layout.padding.compute_flex_edges(
|
|
&self.style.padding,
|
|
axis,
|
|
&mut remaining_flex,
|
|
&mut remaining_length,
|
|
rem_pixels,
|
|
);
|
|
layout.margins.compute_flex_edges(
|
|
&self.style.margins,
|
|
axis,
|
|
&mut remaining_flex,
|
|
&mut remaining_length,
|
|
rem_pixels,
|
|
);
|
|
layout.size.set(
|
|
axis,
|
|
content_size.get(axis)
|
|
+ layout.padding.size().get(axis)
|
|
+ layout.borders.size().get(axis)
|
|
+ layout.margins.size().get(axis),
|
|
);
|
|
}
|
|
Length::Fixed(fixed_length) => {
|
|
let fixed_length = fixed_length.to_pixels(rem_pixels);
|
|
|
|
// With a fixed length, we can only distribute the space in the fixed-length container
|
|
// not consumed by the content.
|
|
let mut padding_flex = self.style.padding.flex().get(axis);
|
|
let mut max_padding_length = (fixed_length - content_size.get(axis)).max(0.);
|
|
layout.padding.compute_flex_edges(
|
|
&self.style.padding,
|
|
axis,
|
|
&mut padding_flex,
|
|
&mut max_padding_length,
|
|
rem_pixels,
|
|
);
|
|
|
|
// Similarly, distribute the available space for margins so we preserve the fixed length
|
|
// of the container.
|
|
let mut margin_flex = self.style.margins.flex().get(axis);
|
|
let mut max_margin_length = constraint.max.get(axis) - fixed_length;
|
|
layout.margins.compute_flex_edges(
|
|
&self.style.margins,
|
|
axis,
|
|
&mut margin_flex,
|
|
&mut max_margin_length,
|
|
rem_pixels,
|
|
);
|
|
|
|
layout
|
|
.size
|
|
.set(axis, fixed_length + layout.margins.size().get(axis))
|
|
}
|
|
Length::Auto { .. } => {
|
|
let mut remaining_flex = total_flex.get(axis);
|
|
let mut remaining_length = fixed_constraint.max.get(axis);
|
|
let flex_length =
|
|
length.flex_pixels(rem_pixels, &mut remaining_flex, &mut remaining_length);
|
|
|
|
layout.padding.compute_flex_edges(
|
|
&self.style.padding,
|
|
axis,
|
|
&mut remaining_flex,
|
|
&mut remaining_length,
|
|
rem_pixels,
|
|
);
|
|
|
|
layout.margins.compute_flex_edges(
|
|
&self.style.margins,
|
|
axis,
|
|
&mut remaining_flex,
|
|
&mut remaining_length,
|
|
rem_pixels,
|
|
);
|
|
|
|
layout.size.set(
|
|
axis,
|
|
flex_length
|
|
+ layout.padding.size().get(axis)
|
|
+ layout.borders.size().get(axis)
|
|
+ layout.margins.size().get(axis),
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
dbg!(self.id_string());
|
|
dbg!(layout)
|
|
}
|
|
}
|
|
|
|
pub struct TopBottom {
|
|
top: Length,
|
|
bottom: Length,
|
|
}
|
|
|
|
impl<T: Into<Length>> From<(T, T)> for TopBottom {
|
|
fn from((top, bottom): (T, T)) -> Self {
|
|
Self {
|
|
top: top.into(),
|
|
bottom: bottom.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Copy + Into<Length>> From<T> for TopBottom {
|
|
fn from(both: T) -> Self {
|
|
Self {
|
|
top: both.into(),
|
|
bottom: both.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct LeftRight {
|
|
left: Length,
|
|
right: Length,
|
|
}
|
|
|
|
impl From<(Length, Length)> for LeftRight {
|
|
fn from((left, right): (Length, Length)) -> Self {
|
|
Self { left, right }
|
|
}
|
|
}
|
|
|
|
impl From<Length> for LeftRight {
|
|
fn from(both: Length) -> Self {
|
|
Self {
|
|
left: both,
|
|
right: both,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Interactive<Style> {
|
|
default: Style,
|
|
hovered: Style,
|
|
active: Style,
|
|
disabled: Style,
|
|
}
|
|
|
|
#[derive(Clone, Default)]
|
|
pub struct NodeStyle {
|
|
axis: Axis3d,
|
|
wrap: bool,
|
|
align: Alignment,
|
|
overflow_x: Overflow,
|
|
overflow_y: Overflow,
|
|
gap_x: Gap,
|
|
gap_y: Gap,
|
|
|
|
size: Size<Length>,
|
|
margins: Edges<Length>,
|
|
padding: Edges<Length>,
|
|
text: OptionalTextStyle,
|
|
opacity: f32,
|
|
fill: Fill,
|
|
borders: Borders,
|
|
corner_radius: f32,
|
|
shadows: Vec<Shadow>,
|
|
}
|
|
|
|
impl NodeStyle {
|
|
fn flex(&self) -> Vector2F {
|
|
self.size.flex() + self.padding.flex() + self.margins.flex()
|
|
}
|
|
}
|
|
|
|
#[optional_struct]
|
|
struct TextStyle {
|
|
size: Rems,
|
|
font_family: Arc<str>,
|
|
weight: FontWeight,
|
|
style: FontStyle,
|
|
}
|
|
|
|
#[derive(Add, Default, Clone)]
|
|
struct Size<T> {
|
|
width: T,
|
|
height: T,
|
|
}
|
|
|
|
impl<T: Copy> Size<T> {
|
|
fn get(&self, axis: Axis2d) -> T {
|
|
match axis {
|
|
Axis2d::X => self.width,
|
|
Axis2d::Y => self.height,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Size<Length> {
|
|
fn fixed_pixels(&self, rem_pixels: f32) -> Size<f32> {
|
|
Size {
|
|
width: self.width.fixed_pixels(rem_pixels),
|
|
height: self.height.fixed_pixels(rem_pixels),
|
|
}
|
|
}
|
|
|
|
pub fn fixed(&self) -> Size<Rems> {
|
|
Size {
|
|
width: self.width.fixed().unwrap_or_default(),
|
|
height: self.height.fixed().unwrap_or_default(),
|
|
}
|
|
}
|
|
|
|
pub fn flex(&self) -> Vector2F {
|
|
vec2f(
|
|
self.width.flex().unwrap_or(0.),
|
|
self.height.flex().unwrap_or(0.),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Size<Rems> {
|
|
pub fn to_pixels(&self, rem_size: f32) -> Vector2F {
|
|
vec2f(
|
|
self.width.to_pixels(rem_size),
|
|
self.height.to_pixels(rem_size),
|
|
)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Default, Debug)]
|
|
pub struct Edges<T> {
|
|
top: T,
|
|
bottom: T,
|
|
left: T,
|
|
right: T,
|
|
}
|
|
|
|
impl<T> Edges<T> {
|
|
fn start(&self, axis: Axis2d) -> &T {
|
|
match axis {
|
|
Axis2d::X => &self.left,
|
|
Axis2d::Y => &self.top,
|
|
}
|
|
}
|
|
|
|
fn start_mut(&mut self, axis: Axis2d) -> &mut T {
|
|
match axis {
|
|
Axis2d::X => &mut self.left,
|
|
Axis2d::Y => &mut self.top,
|
|
}
|
|
}
|
|
|
|
fn end(&self, axis: Axis2d) -> &T {
|
|
match axis {
|
|
Axis2d::X => &self.right,
|
|
Axis2d::Y => &self.bottom,
|
|
}
|
|
}
|
|
|
|
fn end_mut(&mut self, axis: Axis2d) -> &mut T {
|
|
match axis {
|
|
Axis2d::X => &mut self.right,
|
|
Axis2d::Y => &mut self.bottom,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Clone> Edges<T> {
|
|
pub fn set_x(&mut self, value: T) {
|
|
self.left = value.clone();
|
|
self.right = value
|
|
}
|
|
|
|
pub fn set_y(&mut self, value: T) {
|
|
self.top = value.clone();
|
|
self.bottom = value
|
|
}
|
|
}
|
|
|
|
impl Edges<f32> {
|
|
fn size(&self) -> Vector2F {
|
|
vec2f(self.left + self.right, self.top + self.bottom)
|
|
}
|
|
|
|
fn compute_flex_edges(
|
|
&mut self,
|
|
style_edges: &Edges<Length>,
|
|
axis: Axis2d,
|
|
remaining_flex: &mut f32,
|
|
remaining_length: &mut f32,
|
|
rem_pixels: f32,
|
|
) {
|
|
*self.start_mut(axis) +=
|
|
style_edges
|
|
.start(axis)
|
|
.flex_pixels(rem_pixels, remaining_flex, remaining_length);
|
|
*self.end_mut(axis) +=
|
|
style_edges
|
|
.end(axis)
|
|
.flex_pixels(rem_pixels, remaining_flex, remaining_length);
|
|
}
|
|
}
|
|
|
|
impl Edges<Length> {
|
|
fn fixed_pixels(&self, rem_pixels: f32) -> Edges<f32> {
|
|
Edges {
|
|
top: self.top.fixed_pixels(rem_pixels),
|
|
bottom: self.bottom.fixed_pixels(rem_pixels),
|
|
left: self.left.fixed_pixels(rem_pixels),
|
|
right: self.right.fixed_pixels(rem_pixels),
|
|
}
|
|
}
|
|
|
|
fn flex_pixels(
|
|
&self,
|
|
rem_pixels: f32,
|
|
remaining_flex: &mut f32,
|
|
remaining_length: &mut f32,
|
|
) -> Edges<f32> {
|
|
Edges {
|
|
top: self
|
|
.top
|
|
.flex_pixels(rem_pixels, remaining_flex, remaining_length),
|
|
bottom: self
|
|
.bottom
|
|
.flex_pixels(rem_pixels, remaining_flex, remaining_length),
|
|
left: self
|
|
.left
|
|
.flex_pixels(rem_pixels, remaining_flex, remaining_length),
|
|
right: self
|
|
.right
|
|
.flex_pixels(rem_pixels, remaining_flex, remaining_length),
|
|
}
|
|
}
|
|
|
|
// pub fn fixed(&self) -> Size<Rems> {
|
|
// let mut size = Size::default();
|
|
// size.width += self.left.fixed().unwrap_or_default();
|
|
// size.width += self.right.fixed().unwrap_or_default();
|
|
// size
|
|
// }
|
|
|
|
pub fn flex(&self) -> Vector2F {
|
|
vec2f(
|
|
self.left.flex().unwrap_or(0.) + self.right.flex().unwrap_or(0.),
|
|
self.top.flex().unwrap_or(0.) + self.bottom.flex().unwrap_or(0.),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Edges<Rems> {
|
|
pub fn to_pixels(&self, rem_size: f32) -> Edges<f32> {
|
|
Edges {
|
|
top: self.top.to_pixels(rem_size),
|
|
bottom: self.bottom.to_pixels(rem_size),
|
|
left: self.left.to_pixels(rem_size),
|
|
right: self.right.to_pixels(rem_size),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<L> From<L> for Edges<Length>
|
|
where
|
|
L: Into<Length>,
|
|
{
|
|
fn from(uniform: L) -> Self {
|
|
let uniform = uniform.into();
|
|
Edges {
|
|
top: uniform,
|
|
bottom: uniform,
|
|
left: uniform,
|
|
right: uniform,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<Vertical, Horizontal> From<(Vertical, Horizontal)> for Edges<Length>
|
|
where
|
|
Vertical: Into<Length>,
|
|
Horizontal: Into<Length>,
|
|
{
|
|
fn from((vertical, horizontal): (Vertical, Horizontal)) -> Self {
|
|
let vertical = vertical.into();
|
|
let horizontal = horizontal.into();
|
|
Edges {
|
|
top: vertical,
|
|
bottom: vertical,
|
|
left: horizontal,
|
|
right: horizontal,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<Top, Bottom, Left, Right> From<(Top, Bottom, Left, Right)> for Edges<Length>
|
|
where
|
|
Top: Into<Length>,
|
|
Bottom: Into<Length>,
|
|
Left: Into<Length>,
|
|
Right: Into<Length>,
|
|
{
|
|
fn from((top, bottom, left, right): (Top, Bottom, Left, Right)) -> Self {
|
|
Edges {
|
|
top: top.into(),
|
|
bottom: bottom.into(),
|
|
left: left.into(),
|
|
right: right.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
struct CornerRadii {
|
|
top_left: f32,
|
|
top_right: f32,
|
|
bottom_right: f32,
|
|
bottom_left: f32,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub enum Fill {
|
|
Color(Rgba),
|
|
}
|
|
|
|
impl<C: Into<Rgba>> From<C> for Fill {
|
|
fn from(value: C) -> Self {
|
|
Fill::Color(value.into())
|
|
}
|
|
}
|
|
|
|
impl Default for Fill {
|
|
fn default() -> Self {
|
|
Fill::Color(Rgba::default())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Default)]
|
|
struct Borders {
|
|
color: Color,
|
|
width: f32,
|
|
top: bool,
|
|
bottom: bool,
|
|
left: bool,
|
|
right: bool,
|
|
}
|
|
|
|
impl Borders {
|
|
fn is_visible(&self) -> bool {
|
|
self.width > 0.
|
|
&& !self.color.is_fully_transparent()
|
|
&& (self.top || self.bottom || self.left || self.right)
|
|
}
|
|
|
|
fn top_width(&self) -> f32 {
|
|
if self.top {
|
|
self.width
|
|
} else {
|
|
0.
|
|
}
|
|
}
|
|
|
|
fn bottom_width(&self) -> f32 {
|
|
if self.bottom {
|
|
self.width
|
|
} else {
|
|
0.
|
|
}
|
|
}
|
|
|
|
fn left_width(&self) -> f32 {
|
|
if self.left {
|
|
self.width
|
|
} else {
|
|
0.
|
|
}
|
|
}
|
|
|
|
fn right_width(&self) -> f32 {
|
|
if self.right {
|
|
self.width
|
|
} else {
|
|
0.
|
|
}
|
|
}
|
|
|
|
fn edges(&self) -> Edges<f32> {
|
|
let mut edges = Edges::default();
|
|
if self.width > 0. {
|
|
if self.top {
|
|
edges.top = self.width;
|
|
}
|
|
if self.bottom {
|
|
edges.bottom = self.width;
|
|
}
|
|
if self.left {
|
|
edges.left = self.width;
|
|
}
|
|
if self.right {
|
|
edges.right = self.width;
|
|
}
|
|
}
|
|
edges
|
|
}
|
|
|
|
fn size(&self) -> Vector2F {
|
|
let width =
|
|
if self.left { self.width } else { 0. } + if self.right { self.width } else { 0. };
|
|
let height =
|
|
if self.top { self.width } else { 0. } + if self.bottom { self.width } else { 0. };
|
|
|
|
vec2f(width, height)
|
|
}
|
|
}
|
|
|
|
pub mod length {
|
|
use derive_more::{Add, AddAssign, Into};
|
|
|
|
#[derive(Add, AddAssign, Into, Clone, Copy, Default, Debug, PartialEq)]
|
|
pub struct Rems(f32);
|
|
|
|
pub fn rems(rems: f32) -> Rems {
|
|
Rems(rems)
|
|
}
|
|
|
|
impl Rems {
|
|
pub fn to_pixels(&self, rem_pixels: f32) -> f32 {
|
|
self.0 * rem_pixels
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Default, Debug)]
|
|
pub enum Length {
|
|
#[default]
|
|
Hug,
|
|
Fixed(Rems),
|
|
Auto {
|
|
flex: f32,
|
|
min: Rems,
|
|
max: Rems,
|
|
},
|
|
}
|
|
|
|
impl From<Rems> for Length {
|
|
fn from(value: Rems) -> Self {
|
|
Length::Fixed(value)
|
|
}
|
|
}
|
|
|
|
pub fn auto() -> Length {
|
|
flex(1.)
|
|
}
|
|
|
|
pub fn flex(flex: f32) -> Length {
|
|
Length::Auto {
|
|
flex,
|
|
min: Default::default(),
|
|
max: rems(f32::INFINITY),
|
|
}
|
|
}
|
|
|
|
pub fn constrained(flex: f32, min: Option<Rems>, max: Option<Rems>) -> Length {
|
|
Length::Auto {
|
|
flex,
|
|
min: min.unwrap_or(Default::default()),
|
|
max: max.unwrap_or(rems(f32::INFINITY)),
|
|
}
|
|
}
|
|
|
|
impl Length {
|
|
pub fn flex_pixels(
|
|
&self,
|
|
rem_pixels: f32,
|
|
remaining_flex: &mut f32,
|
|
remaining_length: &mut f32,
|
|
) -> f32 {
|
|
match self {
|
|
Length::Auto { flex, min, max } => {
|
|
let flex_length = *remaining_length / *remaining_flex;
|
|
let length = (flex * flex_length)
|
|
.clamp(min.to_pixels(rem_pixels), max.to_pixels(rem_pixels));
|
|
*remaining_flex -= flex;
|
|
*remaining_length -= length;
|
|
length
|
|
}
|
|
_ => 0.,
|
|
}
|
|
}
|
|
|
|
pub fn fixed_pixels(&self, rem: f32) -> f32 {
|
|
match self {
|
|
Length::Fixed(rems) => rems.to_pixels(rem),
|
|
_ => 0.,
|
|
}
|
|
}
|
|
|
|
pub fn flex(&self) -> Option<f32> {
|
|
match self {
|
|
Length::Auto { flex, .. } => Some(*flex),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn fixed(&self) -> Option<Rems> {
|
|
match self {
|
|
Length::Fixed(rems) => Some(*rems),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Deref, DerefMut)]
|
|
struct Alignment(Vector2F);
|
|
|
|
impl Default for Alignment {
|
|
fn default() -> Self {
|
|
Self(vec2f(-1., -1.))
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Default)]
|
|
enum Axis3d {
|
|
X,
|
|
#[default]
|
|
Y,
|
|
Z,
|
|
}
|
|
|
|
impl Axis3d {
|
|
fn to_2d(self) -> Option<Axis2d> {
|
|
match self {
|
|
Axis3d::X => Some(Axis2d::X),
|
|
Axis3d::Y => Some(Axis2d::Y),
|
|
Axis3d::Z => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
|
|
pub enum Axis2d {
|
|
X,
|
|
#[default]
|
|
Y,
|
|
}
|
|
|
|
impl Axis2d {
|
|
fn rotate(self) -> Self {
|
|
match self {
|
|
Axis2d::X => Axis2d::Y,
|
|
Axis2d::Y => Axis2d::X,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Default)]
|
|
enum Overflow {
|
|
#[default]
|
|
Visible,
|
|
Hidden,
|
|
Auto,
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum Gap {
|
|
Fixed(f32),
|
|
Around,
|
|
Between,
|
|
Even,
|
|
}
|
|
|
|
impl Default for Gap {
|
|
fn default() -> Self {
|
|
Gap::Fixed(0.)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Default)]
|
|
struct Shadow {
|
|
offset: Vector2F,
|
|
blur: f32,
|
|
color: Color,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
|
|
enum FontStyle {
|
|
#[default]
|
|
Normal,
|
|
Italic,
|
|
Oblique,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
|
|
enum FontWeight {
|
|
Thin,
|
|
ExtraLight,
|
|
Light,
|
|
#[default]
|
|
Normal,
|
|
Medium,
|
|
Semibold,
|
|
Bold,
|
|
ExtraBold,
|
|
Black,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct Text {
|
|
text: Cow<'static, str>,
|
|
highlights: Option<Box<[(Range<usize>, HighlightStyle)]>>,
|
|
custom_runs: Option<(
|
|
Box<[Range<usize>]>,
|
|
Box<dyn FnMut(usize, RectF, &mut SceneBuilder, &mut AppContext)>,
|
|
)>,
|
|
}
|
|
|
|
pub fn text<V: View>(text: impl Into<Cow<'static, str>>) -> Node<V> {
|
|
row().child(Text {
|
|
text: text.into(),
|
|
..Default::default()
|
|
})
|
|
}
|
|
|
|
#[derive(Default, Debug)]
|
|
pub struct NodeLayout {
|
|
size: Vector2F,
|
|
padding: Edges<f32>,
|
|
borders: Edges<f32>,
|
|
margins: Edges<f32>,
|
|
}
|
|
|
|
impl<V: View> Element<V> for Text {
|
|
type LayoutState = TextLayout;
|
|
type PaintState = ();
|
|
|
|
fn layout(
|
|
&mut self,
|
|
constraint: SizeConstraint,
|
|
_: &mut V,
|
|
cx: &mut LayoutContext<V>,
|
|
) -> (Vector2F, Self::LayoutState) {
|
|
// Convert the string and highlight ranges into an iterator of highlighted chunks.
|
|
let mut offset = 0;
|
|
let mut highlight_ranges = self
|
|
.highlights
|
|
.as_ref()
|
|
.map_or(Default::default(), AsRef::as_ref)
|
|
.iter()
|
|
.peekable();
|
|
let chunks = std::iter::from_fn(|| {
|
|
let result;
|
|
if let Some((range, highlight_style)) = highlight_ranges.peek() {
|
|
if offset < range.start {
|
|
result = Some((&self.text[offset..range.start], None));
|
|
offset = range.start;
|
|
} else if range.end <= self.text.len() {
|
|
result = Some((&self.text[range.clone()], Some(*highlight_style)));
|
|
highlight_ranges.next();
|
|
offset = range.end;
|
|
} else {
|
|
warn!(
|
|
"Highlight out of text range. Text len: {}, Highlight range: {}..{}",
|
|
self.text.len(),
|
|
range.start,
|
|
range.end
|
|
);
|
|
result = None;
|
|
}
|
|
} else if offset < self.text.len() {
|
|
result = Some((&self.text[offset..], None));
|
|
offset = self.text.len();
|
|
} else {
|
|
result = None;
|
|
}
|
|
result
|
|
});
|
|
|
|
let style = cx.text_style();
|
|
|
|
// Perform shaping on these highlighted chunks
|
|
let shaped_lines = layout_highlighted_chunks(
|
|
chunks,
|
|
&style,
|
|
cx.text_layout_cache(),
|
|
&cx.font_cache,
|
|
usize::MAX,
|
|
self.text.matches('\n').count() + 1,
|
|
);
|
|
|
|
// If line wrapping is enabled, wrap each of the shaped lines.
|
|
let font_id = style.font_id;
|
|
let mut line_count = 0;
|
|
let mut max_line_width = 0_f32;
|
|
let mut wrap_boundaries = Vec::new();
|
|
let mut wrapper = cx.font_cache.line_wrapper(font_id, style.font_size);
|
|
for (line, shaped_line) in self.text.split('\n').zip(&shaped_lines) {
|
|
if style.soft_wrap {
|
|
let boundaries = wrapper
|
|
.wrap_shaped_line(line, shaped_line, constraint.max.x())
|
|
.collect::<Vec<_>>();
|
|
line_count += boundaries.len() + 1;
|
|
wrap_boundaries.push(boundaries);
|
|
} else {
|
|
line_count += 1;
|
|
}
|
|
max_line_width = max_line_width.max(shaped_line.width());
|
|
}
|
|
|
|
let line_height = cx.font_cache.line_height(style.font_size);
|
|
let size = vec2f(
|
|
max_line_width
|
|
.ceil()
|
|
.max(constraint.min.x())
|
|
.min(constraint.max.x()),
|
|
(line_height * line_count as f32).ceil(),
|
|
);
|
|
(
|
|
size,
|
|
TextLayout {
|
|
shaped_lines,
|
|
wrap_boundaries,
|
|
line_height,
|
|
},
|
|
)
|
|
}
|
|
|
|
fn paint(
|
|
&mut self,
|
|
scene: &mut SceneBuilder,
|
|
bounds: RectF,
|
|
visible_bounds: RectF,
|
|
layout: &mut Self::LayoutState,
|
|
_: &mut V,
|
|
cx: &mut PaintContext<V>,
|
|
) -> Self::PaintState {
|
|
let mut origin = bounds.origin();
|
|
let empty = Vec::new();
|
|
let mut callback = |_, _, _: &mut SceneBuilder, _: &mut AppContext| {};
|
|
|
|
let mouse_runs;
|
|
let custom_run_callback;
|
|
if let Some((runs, build_region)) = &mut self.custom_runs {
|
|
mouse_runs = runs.iter();
|
|
custom_run_callback = build_region.as_mut();
|
|
} else {
|
|
mouse_runs = [].iter();
|
|
custom_run_callback = &mut callback;
|
|
}
|
|
let mut custom_runs = mouse_runs.enumerate().peekable();
|
|
|
|
let mut offset = 0;
|
|
for (ix, line) in layout.shaped_lines.iter().enumerate() {
|
|
let wrap_boundaries = layout.wrap_boundaries.get(ix).unwrap_or(&empty);
|
|
let boundaries = RectF::new(
|
|
origin,
|
|
vec2f(
|
|
bounds.width(),
|
|
(wrap_boundaries.len() + 1) as f32 * layout.line_height,
|
|
),
|
|
);
|
|
|
|
let style = cx.text_style();
|
|
if boundaries.intersects(visible_bounds) {
|
|
if style.soft_wrap {
|
|
line.paint_wrapped(
|
|
scene,
|
|
origin,
|
|
visible_bounds,
|
|
layout.line_height,
|
|
wrap_boundaries,
|
|
cx,
|
|
);
|
|
} else {
|
|
line.paint(scene, origin, visible_bounds, layout.line_height, cx);
|
|
}
|
|
}
|
|
|
|
// Paint any custom runs that intersect this line.
|
|
let end_offset = offset + line.len();
|
|
if let Some((custom_run_ix, custom_run_range)) = custom_runs.peek().cloned() {
|
|
if custom_run_range.start < end_offset {
|
|
let mut current_custom_run = None;
|
|
if custom_run_range.start <= offset {
|
|
current_custom_run = Some((custom_run_ix, custom_run_range.end, origin));
|
|
}
|
|
|
|
let mut glyph_origin = origin;
|
|
let mut prev_position = 0.;
|
|
let mut wrap_boundaries = wrap_boundaries.iter().copied().peekable();
|
|
for (run_ix, glyph_ix, glyph) in
|
|
line.runs().iter().enumerate().flat_map(|(run_ix, run)| {
|
|
run.glyphs()
|
|
.iter()
|
|
.enumerate()
|
|
.map(move |(ix, glyph)| (run_ix, ix, glyph))
|
|
})
|
|
{
|
|
glyph_origin.set_x(glyph_origin.x() + glyph.position.x() - prev_position);
|
|
prev_position = glyph.position.x();
|
|
|
|
// If we've reached a soft wrap position, move down one line. If there
|
|
// is a custom run in-progress, paint it.
|
|
if wrap_boundaries
|
|
.peek()
|
|
.map_or(false, |b| b.run_ix == run_ix && b.glyph_ix == glyph_ix)
|
|
{
|
|
if let Some((run_ix, _, run_origin)) = &mut current_custom_run {
|
|
let bounds = RectF::from_points(
|
|
*run_origin,
|
|
glyph_origin + vec2f(0., layout.line_height),
|
|
);
|
|
custom_run_callback(*run_ix, bounds, scene, cx);
|
|
*run_origin =
|
|
vec2f(origin.x(), glyph_origin.y() + layout.line_height);
|
|
}
|
|
wrap_boundaries.next();
|
|
glyph_origin = vec2f(origin.x(), glyph_origin.y() + layout.line_height);
|
|
}
|
|
|
|
// If we've reached the end of the current custom run, paint it.
|
|
if let Some((run_ix, run_end_offset, run_origin)) = current_custom_run {
|
|
if offset + glyph.index == run_end_offset {
|
|
current_custom_run.take();
|
|
let bounds = RectF::from_points(
|
|
run_origin,
|
|
glyph_origin + vec2f(0., layout.line_height),
|
|
);
|
|
custom_run_callback(run_ix, bounds, scene, cx);
|
|
custom_runs.next();
|
|
}
|
|
|
|
if let Some((_, run_range)) = custom_runs.peek() {
|
|
if run_range.start >= end_offset {
|
|
break;
|
|
}
|
|
if run_range.start == offset + glyph.index {
|
|
current_custom_run =
|
|
Some((run_ix, run_range.end, glyph_origin));
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we've reached the start of a new custom run, start tracking it.
|
|
if let Some((run_ix, run_range)) = custom_runs.peek() {
|
|
if offset + glyph.index == run_range.start {
|
|
current_custom_run = Some((*run_ix, run_range.end, glyph_origin));
|
|
}
|
|
}
|
|
}
|
|
|
|
// If a custom run extends beyond the end of the line, paint it.
|
|
if let Some((run_ix, run_end_offset, run_origin)) = current_custom_run {
|
|
let line_end = glyph_origin + vec2f(line.width() - prev_position, 0.);
|
|
let bounds = RectF::from_points(
|
|
run_origin,
|
|
line_end + vec2f(0., layout.line_height),
|
|
);
|
|
custom_run_callback(run_ix, bounds, scene, cx);
|
|
if end_offset == run_end_offset {
|
|
custom_runs.next();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
offset = end_offset + 1;
|
|
origin.set_y(boundaries.max_y());
|
|
}
|
|
}
|
|
|
|
fn rect_for_text_range(
|
|
&self,
|
|
_: Range<usize>,
|
|
_: RectF,
|
|
_: RectF,
|
|
_: &Self::LayoutState,
|
|
_: &Self::PaintState,
|
|
_: &V,
|
|
_: &ViewContext<V>,
|
|
) -> Option<RectF> {
|
|
None
|
|
}
|
|
|
|
fn debug(
|
|
&self,
|
|
bounds: RectF,
|
|
_: &Self::LayoutState,
|
|
_: &Self::PaintState,
|
|
_: &V,
|
|
_: &ViewContext<V>,
|
|
) -> Value {
|
|
json!({
|
|
"type": "Text",
|
|
"bounds": bounds.to_json(),
|
|
"text": &self.text,
|
|
})
|
|
}
|
|
}
|
|
|
|
pub struct TextLayout {
|
|
shaped_lines: Vec<Line>,
|
|
wrap_boundaries: Vec<Vec<ShapedBoundary>>,
|
|
line_height: f32,
|
|
}
|
|
|
|
trait Vector2FExt {
|
|
fn infinity() -> Self;
|
|
fn get(self, axis: Axis2d) -> f32;
|
|
fn set(&mut self, axis: Axis2d, value: f32);
|
|
fn increment_x(&mut self, delta: f32) -> f32;
|
|
fn increment_y(&mut self, delta: f32) -> f32;
|
|
}
|
|
|
|
impl Vector2FExt for Vector2F {
|
|
fn infinity() -> Self {
|
|
vec2f(f32::INFINITY, f32::INFINITY)
|
|
}
|
|
|
|
fn get(self, axis: Axis2d) -> f32 {
|
|
match axis {
|
|
Axis2d::X => self.x(),
|
|
Axis2d::Y => self.y(),
|
|
}
|
|
}
|
|
|
|
fn set(&mut self, axis: Axis2d, value: f32) {
|
|
match axis {
|
|
Axis2d::X => self.set_x(value),
|
|
Axis2d::Y => self.set_y(value),
|
|
}
|
|
}
|
|
|
|
fn increment_x(&mut self, delta: f32) -> f32 {
|
|
self.set_x(self.x() + delta);
|
|
self.x()
|
|
}
|
|
|
|
fn increment_y(&mut self, delta: f32) -> f32 {
|
|
self.set_y(self.y() + delta);
|
|
self.y()
|
|
}
|
|
}
|
|
|
|
trait ElementExt<V: View> {
|
|
fn margin_left(self, margin_left: impl Into<Length>) -> Node<V>
|
|
where
|
|
Self: Element<V> + Sized,
|
|
{
|
|
column().child(self).margin_left(margin_left)
|
|
}
|
|
}
|
|
|
|
impl<V, E> ElementExt<V> for E
|
|
where
|
|
V: View,
|
|
E: Element<V>,
|
|
{
|
|
fn margin_left(self, margin_left: impl Into<Length>) -> Node<V>
|
|
where
|
|
Self: Sized,
|
|
{
|
|
column().child(self).margin_left(margin_left)
|
|
}
|
|
}
|
|
|
|
pub fn view<F, E>(mut function: F) -> ViewFn
|
|
where
|
|
F: 'static + FnMut(&mut ViewContext<ViewFn>) -> E,
|
|
E: Element<ViewFn>,
|
|
{
|
|
ViewFn(Box::new(move |cx| (function)(cx).into_any()))
|
|
}
|
|
|
|
pub struct ViewFn(Box<dyn FnMut(&mut ViewContext<ViewFn>) -> AnyElement<ViewFn>>);
|
|
|
|
impl Entity for ViewFn {
|
|
type Event = ();
|
|
}
|
|
|
|
impl View for ViewFn {
|
|
fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
|
|
(self.0)(cx)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{
|
|
length::{auto, rems},
|
|
*,
|
|
};
|
|
use crate::themes::rose_pine;
|
|
use gpui::TestAppContext;
|
|
|
|
#[gpui::test]
|
|
fn test_layout(cx: &mut TestAppContext) {
|
|
let window = cx.add_window(|_| {
|
|
view(|_| {
|
|
let theme = rose_pine::dawn();
|
|
column()
|
|
.width(auto())
|
|
.height(auto())
|
|
.justify(1.)
|
|
.child(
|
|
row()
|
|
.width(auto())
|
|
.height(rems(10.))
|
|
.fill(theme.foam)
|
|
.justify(1.)
|
|
.child(row().width(rems(10.)).height(auto()).fill(theme.gold)),
|
|
)
|
|
.child(row())
|
|
});
|
|
});
|
|
|
|
// tree.layout(
|
|
// SizeConstraint::strict(vec2f(100., 100.)),
|
|
// &mut (),
|
|
// LayoutContext::test(),
|
|
// );
|
|
|
|
// LayoutContext::new(
|
|
// cx,
|
|
// new_parents,
|
|
// views_to_notify_if_ancestors_change,
|
|
// refreshing,
|
|
// )
|
|
|
|
// tree.layout(SizeConstraint::strict(vec2f(100., 100.)), &mut (), cx)
|
|
}
|
|
}
|