mirrors/zed
1
0
Fork 0
mirror of https://github.com/zed-industries/zed.git synced 2024-12-25 01:34:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9
zed/test.rs
Nathan Sobo 3b5ee59273 Split playground into gpui2 and storybook
2023-08-30 16:12:14 -06:00

5618 lines
171 KiB
Rust
Raw Blame History

#![feature(prelude_import)]
#![allow(dead_code, unused_variables)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use color::black;
use components::button;
use element::Element;
use frame::frame;
use gpui::{
geometry::{rect::RectF, vector::vec2f},
platform::WindowOptions,
};
use log::LevelFilter;
use simplelog::SimpleLogger;
use themes::{rose_pine, ThemeColors};
use view::view;
mod adapter {
use crate::element::AnyElement;
use crate::element::{LayoutContext, PaintContext};
use gpui::{geometry::rect::RectF, LayoutEngine};
use util::ResultExt;
pub struct Adapter<V>(pub(crate) AnyElement<V>);
impl<V: 'static> gpui::Element<V> for Adapter<V> {
type LayoutState = Option<LayoutEngine>;
type PaintState = ();
fn layout(
&mut self,
constraint: gpui::SizeConstraint,
view: &mut V,
cx: &mut LayoutContext<V>,
) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
cx.push_layout_engine(LayoutEngine::new());
let node = self.0.layout(view, cx).log_err();
if let Some(node) = node {
let layout_engine = cx.layout_engine().unwrap();
layout_engine.compute_layout(node, constraint.max).log_err();
}
let layout_engine = cx.pop_layout_engine();
if true {
if !layout_engine.is_some() {
::core::panicking::panic("assertion failed: layout_engine.is_some()")
}
}
(constraint.max, layout_engine)
}
fn paint(
&mut self,
scene: &mut gpui::SceneBuilder,
bounds: RectF,
visible_bounds: RectF,
layout_engine: &mut Option<LayoutEngine>,
view: &mut V,
legacy_cx: &mut gpui::PaintContext<V>,
) -> Self::PaintState {
legacy_cx.push_layout_engine(layout_engine.take().unwrap());
let mut cx = PaintContext::new(legacy_cx, scene);
self.0.paint(view, &mut cx).log_err();
*layout_engine = legacy_cx.pop_layout_engine();
if true {
if !layout_engine.is_some() {
::core::panicking::panic("assertion failed: layout_engine.is_some()")
}
}
}
fn rect_for_text_range(
&self,
range_utf16: std::ops::Range<usize>,
bounds: RectF,
visible_bounds: RectF,
layout: &Self::LayoutState,
paint: &Self::PaintState,
view: &V,
cx: &gpui::ViewContext<V>,
) -> Option<RectF> {
::core::panicking::panic("not yet implemented")
}
fn debug(
&self,
bounds: RectF,
layout: &Self::LayoutState,
paint: &Self::PaintState,
view: &V,
cx: &gpui::ViewContext<V>,
) -> gpui::serde_json::Value {
::core::panicking::panic("not yet implemented")
}
}
}
mod color {
#![allow(dead_code)]
use smallvec::SmallVec;
use std::{num::ParseIntError, ops::Range};
pub fn rgb<C: From<Rgba>>(hex: u32) -> C {
let r = ((hex >> 16) & 0xFF) as f32 / 255.0;
let g = ((hex >> 8) & 0xFF) as f32 / 255.0;
let b = (hex & 0xFF) as f32 / 255.0;
Rgba { r, g, b, a: 1.0 }.into()
}
pub struct Rgba {
pub r: f32,
pub g: f32,
pub b: f32,
pub a: f32,
}
#[automatically_derived]
impl ::core::clone::Clone for Rgba {
#[inline]
fn clone(&self) -> Rgba {
let _: ::core::clone::AssertParamIsClone<f32>;
*self
}
}
#[automatically_derived]
impl ::core::marker::Copy for Rgba {}
#[automatically_derived]
impl ::core::default::Default for Rgba {
#[inline]
fn default() -> Rgba {
Rgba {
r: ::core::default::Default::default(),
g: ::core::default::Default::default(),
b: ::core::default::Default::default(),
a: ::core::default::Default::default(),
}
}
}
#[automatically_derived]
impl ::core::fmt::Debug for Rgba {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field4_finish(
f, "Rgba", "r", &self.r, "g", &self.g, "b", &self.b, "a", &&self.a,
)
}
}
pub trait Lerp {
fn lerp(&self, level: f32) -> Hsla;
}
impl Lerp for Range<Hsla> {
fn lerp(&self, level: f32) -> Hsla {
let level = level.clamp(0., 1.);
Hsla {
h: self.start.h + (level * (self.end.h - self.start.h)),
s: self.start.s + (level * (self.end.s - self.start.s)),
l: self.start.l + (level * (self.end.l - self.start.l)),
a: self.start.a + (level * (self.end.a - self.start.a)),
}
}
}
impl From<gpui::color::Color> for Rgba {
fn from(value: gpui::color::Color) -> Self {
Self {
r: value.0.r as f32 / 255.0,
g: value.0.g as f32 / 255.0,
b: value.0.b as f32 / 255.0,
a: value.0.a as f32 / 255.0,
}
}
}
impl From<Hsla> for Rgba {
fn from(color: Hsla) -> Self {
let h = color.h;
let s = color.s;
let l = color.l;
let c = (1.0 - (2.0 * l - 1.0).abs()) * s;
let x = c * (1.0 - ((h * 6.0) % 2.0 - 1.0).abs());
let m = l - c / 2.0;
let cm = c + m;
let xm = x + m;
let (r, g, b) = match (h * 6.0).floor() as i32 {
0 | 6 => (cm, xm, m),
1 => (xm, cm, m),
2 => (m, cm, xm),
3 => (m, xm, cm),
4 => (xm, m, cm),
_ => (cm, m, xm),
};
Rgba {
r,
g,
b,
a: color.a,
}
}
}
impl TryFrom<&'_ str> for Rgba {
type Error = ParseIntError;
fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
let r = u8::from_str_radix(&value[1..3], 16)? as f32 / 255.0;
let g = u8::from_str_radix(&value[3..5], 16)? as f32 / 255.0;
let b = u8::from_str_radix(&value[5..7], 16)? as f32 / 255.0;
let a = if value.len() > 7 {
u8::from_str_radix(&value[7..9], 16)? as f32 / 255.0
} else {
1.0
};
Ok(Rgba { r, g, b, a })
}
}
impl Into<gpui::color::Color> for Rgba {
fn into(self) -> gpui::color::Color {
gpui::color::rgba(self.r, self.g, self.b, self.a)
}
}
pub struct Hsla {
pub h: f32,
pub s: f32,
pub l: f32,
pub a: f32,
}
#[automatically_derived]
impl ::core::default::Default for Hsla {
#[inline]
fn default() -> Hsla {
Hsla {
h: ::core::default::Default::default(),
s: ::core::default::Default::default(),
l: ::core::default::Default::default(),
a: ::core::default::Default::default(),
}
}
}
#[automatically_derived]
impl ::core::marker::Copy for Hsla {}
#[automatically_derived]
impl ::core::clone::Clone for Hsla {
#[inline]
fn clone(&self) -> Hsla {
let _: ::core::clone::AssertParamIsClone<f32>;
*self
}
}
#[automatically_derived]
impl ::core::fmt::Debug for Hsla {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field4_finish(
f, "Hsla", "h", &self.h, "s", &self.s, "l", &self.l, "a", &&self.a,
)
}
}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for Hsla {}
#[automatically_derived]
impl ::core::cmp::PartialEq for Hsla {
#[inline]
fn eq(&self, other: &Hsla) -> bool {
self.h == other.h && self.s == other.s && self.l == other.l && self.a == other.a
}
}
pub fn hsla(h: f32, s: f32, l: f32, a: f32) -> Hsla {
Hsla {
h: h.clamp(0., 1.),
s: s.clamp(0., 1.),
l: l.clamp(0., 1.),
a: a.clamp(0., 1.),
}
}
pub fn black() -> Hsla {
Hsla {
h: 0.,
s: 0.,
l: 0.,
a: 1.,
}
}
impl From<Rgba> for Hsla {
fn from(color: Rgba) -> Self {
let r = color.r;
let g = color.g;
let b = color.b;
let max = r.max(g.max(b));
let min = r.min(g.min(b));
let delta = max - min;
let l = (max + min) / 2.0;
let s = if l == 0.0 || l == 1.0 {
0.0
} else if l < 0.5 {
delta / (2.0 * l)
} else {
delta / (2.0 - 2.0 * l)
};
let h = if delta == 0.0 {
0.0
} else if max == r {
((g - b) / delta).rem_euclid(6.0) / 6.0
} else if max == g {
((b - r) / delta + 2.0) / 6.0
} else {
((r - g) / delta + 4.0) / 6.0
};
Hsla {
h,
s,
l,
a: color.a,
}
}
}
impl Hsla {
/// Scales the saturation and lightness by the given values, clamping at 1.0.
pub fn scale_sl(mut self, s: f32, l: f32) -> Self {
self.s = (self.s * s).clamp(0., 1.);
self.l = (self.l * l).clamp(0., 1.);
self
}
/// Increases the saturation of the color by a certain amount, with a max
/// value of 1.0.
pub fn saturate(mut self, amount: f32) -> Self {
self.s += amount;
self.s = self.s.clamp(0.0, 1.0);
self
}
/// Decreases the saturation of the color by a certain amount, with a min
/// value of 0.0.
pub fn desaturate(mut self, amount: f32) -> Self {
self.s -= amount;
self.s = self.s.max(0.0);
if self.s < 0.0 {
self.s = 0.0;
}
self
}
/// Brightens the color by increasing the lightness by a certain amount,
/// with a max value of 1.0.
pub fn brighten(mut self, amount: f32) -> Self {
self.l += amount;
self.l = self.l.clamp(0.0, 1.0);
self
}
/// Darkens the color by decreasing the lightness by a certain amount,
/// with a max value of 0.0.
pub fn darken(mut self, amount: f32) -> Self {
self.l -= amount;
self.l = self.l.clamp(0.0, 1.0);
self
}
}
impl From<gpui::color::Color> for Hsla {
fn from(value: gpui::color::Color) -> Self {
Rgba::from(value).into()
}
}
impl Into<gpui::color::Color> for Hsla {
fn into(self) -> gpui::color::Color {
Rgba::from(self).into()
}
}
pub struct ColorScale {
colors: SmallVec<[Hsla; 2]>,
positions: SmallVec<[f32; 2]>,
}
pub fn scale<I, C>(colors: I) -> ColorScale
where
I: IntoIterator<Item = C>,
C: Into<Hsla>,
{
let mut scale = ColorScale {
colors: colors.into_iter().map(Into::into).collect(),
positions: SmallVec::new(),
};
let num_colors: f32 = scale.colors.len() as f32 - 1.0;
scale.positions = (0..scale.colors.len())
.map(|i| i as f32 / num_colors)
.collect();
scale
}
impl ColorScale {
fn at(&self, t: f32) -> Hsla {
if true {
if !(0.0 <= t && t <= 1.0) {
{
::core::panicking::panic_fmt(format_args!(
"t value {0} is out of range. Expected value in range 0.0 to 1.0",
t,
));
}
}
}
let position = match self
.positions
.binary_search_by(|a| a.partial_cmp(&t).unwrap())
{
Ok(index) | Err(index) => index,
};
let lower_bound = position.saturating_sub(1);
let upper_bound = position.min(self.colors.len() - 1);
let lower_color = &self.colors[lower_bound];
let upper_color = &self.colors[upper_bound];
match upper_bound.checked_sub(lower_bound) {
Some(0) | None => *lower_color,
Some(_) => {
let interval_t = (t - self.positions[lower_bound])
/ (self.positions[upper_bound] - self.positions[lower_bound]);
let h = lower_color.h + interval_t * (upper_color.h - lower_color.h);
let s = lower_color.s + interval_t * (upper_color.s - lower_color.s);
let l = lower_color.l + interval_t * (upper_color.l - lower_color.l);
let a = lower_color.a + interval_t * (upper_color.a - lower_color.a);
Hsla { h, s, l, a }
}
}
}
}
}
mod components {
use crate::{
element::{Element, ElementMetadata},
frame,
text::ArcCow,
themes::rose_pine,
};
use gpui::{platform::MouseButton, ViewContext};
use gpui2_macros::Element;
use std::{marker::PhantomData, rc::Rc};
struct ButtonHandlers<V, D> {
click: Option<Rc<dyn Fn(&mut V, &D, &mut ViewContext<V>)>>,
}
impl<V, D> Default for ButtonHandlers<V, D> {
fn default() -> Self {
Self { click: None }
}
}
#[element_crate = "crate"]
pub struct Button<V: 'static, D: 'static> {
metadata: ElementMetadata<V>,
handlers: ButtonHandlers<V, D>,
label: Option<ArcCow<'static, str>>,
icon: Option<ArcCow<'static, str>>,
data: Rc<D>,
view_type: PhantomData<V>,
}
impl<V: 'static, D: 'static> crate::element::Element<V> for Button<V, D> {
type Layout = crate::element::AnyElement<V>;
fn declared_style(&mut self) -> &mut crate::style::OptionalStyle {
&mut self.metadata.style
}
fn handlers_mut(&mut self) -> &mut Vec<crate::element::EventHandler<V>> {
&mut self.metadata.handlers
}
fn layout(
&mut self,
view: &mut V,
cx: &mut crate::element::LayoutContext<V>,
) -> anyhow::Result<(taffy::tree::NodeId, Self::Layout)> {
let mut element = self.render(view, cx).into_any();
let node_id = element.layout(view, cx)?;
Ok((node_id, element))
}
fn paint<'a>(
&mut self,
layout: crate::element::Layout<'a, Self::Layout>,
view: &mut V,
cx: &mut crate::element::PaintContext<V>,
) -> anyhow::Result<()> {
layout.from_element.paint(view, cx)?;
Ok(())
}
}
impl<V: 'static, D: 'static> crate::element::IntoElement<V> for Button<V, D> {
type Element = Self;
fn into_element(self) -> Self {
self
}
}
impl<V: 'static> Button<V, ()> {
fn new() -> Self {
Self {
metadata: Default::default(),
handlers: ButtonHandlers::default(),
label: None,
icon: None,
data: Rc::new(()),
view_type: PhantomData,
}
}
pub fn data<D: 'static>(self, data: D) -> Button<V, D> {
Button {
metadata: Default::default(),
handlers: ButtonHandlers::default(),
label: self.label,
icon: self.icon,
data: Rc::new(data),
view_type: PhantomData,
}
}
}
impl<V: 'static, D: 'static> Button<V, D> {
pub fn label(mut self, label: impl Into<ArcCow<'static, str>>) -> Self {
self.label = Some(label.into());
self
}
pub fn icon(mut self, icon: impl Into<ArcCow<'static, str>>) -> Self {
self.icon = Some(icon.into());
self
}
pub fn click(self, handler: impl Fn(&mut V, &D, &mut ViewContext<V>) + 'static) -> Self {
let data = self.data.clone();
Element::click(self, MouseButton::Left, move |view, _, cx| {
handler(view, data.as_ref(), cx);
})
}
}
pub fn button<V>() -> Button<V, ()> {
Button::new()
}
impl<V: 'static, D: 'static> Button<V, D> {
fn render(&mut self, view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
let button = frame()
.fill(rose_pine::dawn().error(0.5))
.h_4()
.children(self.label.clone());
if let Some(handler) = self.handlers.click.clone() {
let data = self.data.clone();
button.mouse_down(MouseButton::Left, move |view, event, cx| {
handler(view, data.as_ref(), cx)
})
} else {
button
}
}
}
}
mod element {
pub use crate::paint_context::PaintContext;
use crate::{
adapter::Adapter,
color::Hsla,
hoverable::Hoverable,
style::{Display, Fill, OptionalStyle, Overflow, Position},
};
use anyhow::Result;
pub use gpui::LayoutContext;
use gpui::{
geometry::{DefinedLength, Length, OptionalPoint},
platform::{MouseButton, MouseButtonEvent},
EngineLayout, EventContext, RenderContext, ViewContext,
};
use gpui2_macros::tailwind_lengths;
use std::{
any::{Any, TypeId},
cell::Cell,
rc::Rc,
};
pub use taffy::tree::NodeId;
pub struct Layout<'a, E: ?Sized> {
pub from_engine: EngineLayout,
pub from_element: &'a mut E,
}
pub struct ElementMetadata<V> {
pub style: OptionalStyle,
pub handlers: Vec<EventHandler<V>>,
}
pub struct EventHandler<V> {
handler: Rc<dyn Fn(&mut V, &dyn Any, &mut EventContext<V>)>,
event_type: TypeId,
outside_bounds: bool,
}
impl<V> Clone for EventHandler<V> {
fn clone(&self) -> Self {
Self {
handler: self.handler.clone(),
event_type: self.event_type,
outside_bounds: self.outside_bounds,
}
}
}
impl<V> Default for ElementMetadata<V> {
fn default() -> Self {
Self {
style: OptionalStyle::default(),
handlers: Vec::new(),
}
}
}
pub trait Element<V: 'static>: 'static {
type Layout: 'static;
fn declared_style(&mut self) -> &mut OptionalStyle;
fn computed_style(&mut self) -> &OptionalStyle {
self.declared_style()
}
fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>>;
fn layout(
&mut self,
view: &mut V,
cx: &mut LayoutContext<V>,
) -> Result<(NodeId, Self::Layout)>;
fn paint<'a>(
&mut self,
layout: Layout<Self::Layout>,
view: &mut V,
cx: &mut PaintContext<V>,
) -> Result<()>;
/// Convert to a dynamically-typed element suitable for layout and paint.
fn into_any(self) -> AnyElement<V>
where
Self: 'static + Sized,
{
AnyElement {
element: Box::new(self) as Box<dyn ElementObject<V>>,
layout: None,
}
}
fn adapt(self) -> Adapter<V>
where
Self: Sized,
Self: Element<V>,
{
Adapter(self.into_any())
}
fn click(
self,
button: MouseButton,
handler: impl Fn(&mut V, &MouseButtonEvent, &mut ViewContext<V>) + 'static,
) -> Self
where
Self: Sized,
{
let pressed: Rc<Cell<bool>> = Default::default();
self.mouse_down(button, {
let pressed = pressed.clone();
move |_, _, _| {
pressed.set(true);
}
})
.mouse_up_outside(button, {
let pressed = pressed.clone();
move |_, _, _| {
pressed.set(false);
}
})
.mouse_up(button, move |view, event, event_cx| {
if pressed.get() {
pressed.set(false);
handler(view, event, event_cx);
}
})
}
fn mouse_down(
mut self,
button: MouseButton,
handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
) -> Self
where
Self: Sized,
{
self.handlers_mut().push(EventHandler {
handler: Rc::new(move |view, event, event_cx| {
let event = event.downcast_ref::<MouseButtonEvent>().unwrap();
if event.button == button && event.is_down {
handler(view, event, event_cx);
}
}),
event_type: TypeId::of::<MouseButtonEvent>(),
outside_bounds: false,
});
self
}
fn mouse_down_outside(
mut self,
button: MouseButton,
handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
) -> Self
where
Self: Sized,
{
self.handlers_mut().push(EventHandler {
handler: Rc::new(move |view, event, event_cx| {
let event = event.downcast_ref::<MouseButtonEvent>().unwrap();
if event.button == button && event.is_down {
handler(view, event, event_cx);
}
}),
event_type: TypeId::of::<MouseButtonEvent>(),
outside_bounds: true,
});
self
}
fn mouse_up(
mut self,
button: MouseButton,
handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
) -> Self
where
Self: Sized,
{
self.handlers_mut().push(EventHandler {
handler: Rc::new(move |view, event, event_cx| {
let event = event.downcast_ref::<MouseButtonEvent>().unwrap();
if event.button == button && !event.is_down {
handler(view, event, event_cx);
}
}),
event_type: TypeId::of::<MouseButtonEvent>(),
outside_bounds: false,
});
self
}
fn mouse_up_outside(
mut self,
button: MouseButton,
handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
) -> Self
where
Self: Sized,
{
self.handlers_mut().push(EventHandler {
handler: Rc::new(move |view, event, event_cx| {
let event = event.downcast_ref::<MouseButtonEvent>().unwrap();
if event.button == button && !event.is_down {
handler(view, event, event_cx);
}
}),
event_type: TypeId::of::<MouseButtonEvent>(),
outside_bounds: true,
});
self
}
fn block(mut self) -> Self
where
Self: Sized,
{
self.declared_style().display = Some(Display::Block);
self
}
fn flex(mut self) -> Self
where
Self: Sized,
{
self.declared_style().display = Some(Display::Flex);
self
}
fn grid(mut self) -> Self
where
Self: Sized,
{
self.declared_style().display = Some(Display::Grid);
self
}
fn overflow_visible(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow = OptionalPoint {
x: Some(Overflow::Visible),
y: Some(Overflow::Visible),
};
self
}
fn overflow_hidden(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow = OptionalPoint {
x: Some(Overflow::Hidden),
y: Some(Overflow::Hidden),
};
self
}
fn overflow_scroll(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow = OptionalPoint {
x: Some(Overflow::Scroll),
y: Some(Overflow::Scroll),
};
self
}
fn overflow_x_visible(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow.x = Some(Overflow::Visible);
self
}
fn overflow_x_hidden(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow.x = Some(Overflow::Hidden);
self
}
fn overflow_x_scroll(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow.x = Some(Overflow::Scroll);
self
}
fn overflow_y_visible(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow.y = Some(Overflow::Visible);
self
}
fn overflow_y_hidden(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow.y = Some(Overflow::Hidden);
self
}
fn overflow_y_scroll(mut self) -> Self
where
Self: Sized,
{
self.declared_style().overflow.y = Some(Overflow::Scroll);
self
}
fn relative(mut self) -> Self
where
Self: Sized,
{
self.declared_style().position = Some(Position::Relative);
self
}
fn absolute(mut self) -> Self
where
Self: Sized,
{
self.declared_style().position = Some(Position::Absolute);
self
}
fn inset_0(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Pixels(0.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_px(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Pixels(1.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_0_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.125).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_1(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.25).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_1_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.375).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_2(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.5).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_2_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.625).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_3(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.75).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_3_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.875).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_4(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.25).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_6(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.5).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_7(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.75).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_8(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_9(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.25).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_10(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.5).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_11(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.75).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_12(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(3.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_14(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(3.5).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_16(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(4.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_20(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(5.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_24(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(6.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_28(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(7.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_32(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(8.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_36(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(9.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_40(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(10.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_44(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(11.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_48(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(12.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_52(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(13.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_56(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(14.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_60(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(15.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_64(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(16.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_72(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(18.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_80(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(20.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_96(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(24.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_half(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_1_3rd(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_2_3rd(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_1_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(25.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_2_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_3_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(75.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_1_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(20.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_2_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(40.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_3_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(60.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_4_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(80.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_1_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(16.666667).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_2_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_3_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_4_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_5_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(83.333333).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_1_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(8.333333).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_2_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(16.666667).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_3_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(25.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_4_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_5_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(41.666667).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_6_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_7_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(58.333333).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_8_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_9_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(75.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_10_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(83.333333).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_11_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(91.666667).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn inset_full(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(100.).into();
{
let inset = self
.computed_style()
.inset
.get_or_insert_with(Default::default);
inset.top = length;
inset.right = length;
inset.bottom = length;
inset.left = length;
self
}
}
fn w(mut self, width: impl Into<Length>) -> Self
where
Self: Sized,
{
self.declared_style().size.width = Some(width.into());
self
}
fn w_auto(mut self) -> Self
where
Self: Sized,
{
self.declared_style().size.width = Some(Length::Auto);
self
}
fn w_0(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Pixels(0.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_px(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Pixels(1.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_0_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.125).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_1(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.25).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_1_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.375).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_2(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.5).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_2_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.625).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_3(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.75).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_3_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.875).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_4(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.25).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_6(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.5).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_7(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.75).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_8(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_9(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.25).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_10(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.5).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_11(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.75).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_12(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(3.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_14(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(3.5).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_16(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(4.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_20(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(5.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_24(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(6.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_28(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(7.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_32(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(8.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_36(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(9.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_40(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(10.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_44(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(11.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_48(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(12.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_52(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(13.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_56(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(14.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_60(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(15.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_64(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(16.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_72(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(18.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_80(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(20.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_96(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(24.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_half(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_1_3rd(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_2_3rd(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_1_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(25.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_2_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_3_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(75.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_1_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(20.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_2_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(40.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_3_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(60.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_4_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(80.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_1_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(16.666667).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_2_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_3_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_4_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_5_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(83.333333).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_1_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(8.333333).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_2_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(16.666667).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_3_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(25.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_4_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_5_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(41.666667).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_6_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_7_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(58.333333).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_8_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_9_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(75.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_10_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(83.333333).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_11_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(91.666667).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn w_full(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(100.).into();
{
self.declared_style().size.width = Some(length);
self
}
}
fn min_w_0(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Pixels(0.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_px(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Pixels(1.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_0_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.125).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_1(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.25).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_1_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.375).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_2(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.5).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_2_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.625).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_3(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.75).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_3_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.875).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_4(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.25).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_6(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.5).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_7(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.75).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_8(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_9(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.25).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_10(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.5).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_11(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.75).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_12(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(3.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_14(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(3.5).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_16(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(4.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_20(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(5.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_24(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(6.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_28(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(7.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_32(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(8.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_36(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(9.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_40(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(10.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_44(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(11.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_48(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(12.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_52(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(13.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_56(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(14.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_60(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(15.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_64(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(16.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_72(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(18.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_80(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(20.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_96(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(24.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_half(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_1_3rd(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_2_3rd(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_1_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(25.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_2_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_3_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(75.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_1_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(20.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_2_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(40.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_3_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(60.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_4_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(80.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_1_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(16.666667).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_2_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_3_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_4_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_5_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(83.333333).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_1_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(8.333333).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_2_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(16.666667).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_3_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(25.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_4_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_5_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(41.666667).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_6_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_7_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(58.333333).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_8_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_9_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(75.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_10_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(83.333333).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_11_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(91.666667).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn min_w_full(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(100.).into();
{
self.declared_style().min_size.width = Some(length);
self
}
}
fn h(mut self, height: impl Into<Length>) -> Self
where
Self: Sized,
{
self.declared_style().size.height = Some(height.into());
self
}
fn h_auto(mut self) -> Self
where
Self: Sized,
{
self.declared_style().size.height = Some(Length::Auto);
self
}
fn h_0(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Pixels(0.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_px(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Pixels(1.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_0_5(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(0.125).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_1(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(0.25).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_1_5(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(0.375).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_2(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(0.5).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_2_5(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(0.625).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_3(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(0.75).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_3_5(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(0.875).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_4(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(1.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_5(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(1.25).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_6(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(1.5).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_7(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(1.75).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_8(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(2.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_9(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(2.25).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_10(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(2.5).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_11(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(2.75).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_12(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(3.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_14(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(3.5).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_16(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(4.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_20(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(5.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_24(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(6.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_28(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(7.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_32(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(8.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_36(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(9.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_40(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(10.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_44(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(11.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_48(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(12.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_52(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(13.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_56(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(14.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_60(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(15.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_64(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(16.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_72(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(18.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_80(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(20.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_96(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Rems(24.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_half(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(50.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_1_3rd(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(33.333333).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_2_3rd(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(66.666667).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_1_4th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(25.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_2_4th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(50.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_3_4th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(75.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_1_5th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(20.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_2_5th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(40.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_3_5th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(60.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_4_5th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(80.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_1_6th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(16.666667).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_2_6th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(33.333333).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_3_6th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(50.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_4_6th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(66.666667).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_5_6th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(83.333333).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_1_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(8.333333).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_2_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(16.666667).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_3_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(25.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_4_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(33.333333).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_5_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(41.666667).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_6_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(50.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_7_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(58.333333).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_8_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(66.666667).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_9_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(75.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_10_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(83.333333).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_11_12th(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(91.666667).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn h_full(mut self) -> Self
where
Self: Sized,
{
let height = DefinedLength::Percent(100.).into();
{
self.declared_style().size.height = Some(height);
self
}
}
fn min_h_0(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Pixels(0.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_px(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Pixels(1.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_0_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.125).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_1(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.25).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_1_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.375).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_2(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.5).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_2_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.625).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_3(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.75).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_3_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(0.875).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_4(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_5(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.25).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_6(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.5).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_7(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(1.75).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_8(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_9(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.25).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_10(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.5).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_11(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(2.75).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_12(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(3.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_14(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(3.5).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_16(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(4.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_20(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(5.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_24(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(6.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_28(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(7.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_32(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(8.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_36(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(9.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_40(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(10.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_44(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(11.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_48(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(12.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_52(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(13.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_56(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(14.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_60(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(15.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_64(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(16.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_72(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(18.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_80(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(20.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_96(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Rems(24.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_half(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_1_3rd(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_2_3rd(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_1_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(25.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_2_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_3_4th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(75.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_1_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(20.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_2_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(40.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_3_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(60.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_4_5th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(80.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_1_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(16.666667).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_2_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_3_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_4_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_5_6th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(83.333333).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_1_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(8.333333).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_2_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(16.666667).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_3_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(25.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_4_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(33.333333).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_5_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(41.666667).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_6_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(50.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_7_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(58.333333).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_8_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(66.666667).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_9_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(75.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_10_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(83.333333).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_11_12th(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(91.666667).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn min_h_full(mut self) -> Self
where
Self: Sized,
{
let length = DefinedLength::Percent(100.).into();
{
self.declared_style().min_size.height = Some(length);
self
}
}
fn hoverable(self) -> Hoverable<V, Self>
where
Self: Sized,
{
Hoverable::new(self)
}
fn fill(mut self, fill: impl Into<Fill>) -> Self
where
Self: Sized,
{
self.declared_style().fill = Some(Some(fill.into()));
self
}
fn text_color(mut self, color: impl Into<Hsla>) -> Self
where
Self: Sized,
{
self.declared_style().text_color = Some(Some(color.into()));
self
}
}
trait ElementObject<V> {
fn style(&mut self) -> &mut OptionalStyle;
fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>>;
fn layout(
&mut self,
view: &mut V,
cx: &mut LayoutContext<V>,
) -> Result<(NodeId, Box<dyn Any>)>;
fn paint(
&mut self,
layout: Layout<dyn Any>,
view: &mut V,
cx: &mut PaintContext<V>,
) -> Result<()>;
}
impl<V: 'static, E: Element<V>> ElementObject<V> for E {
fn style(&mut self) -> &mut OptionalStyle {
Element::declared_style(self)
}
fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>> {
Element::handlers_mut(self)
}
fn layout(
&mut self,
view: &mut V,
cx: &mut LayoutContext<V>,
) -> Result<(NodeId, Box<dyn Any>)> {
let (node_id, layout) = self.layout(view, cx)?;
let layout = Box::new(layout) as Box<dyn Any>;
Ok((node_id, layout))
}
fn paint(
&mut self,
layout: Layout<dyn Any>,
view: &mut V,
cx: &mut PaintContext<V>,
) -> Result<()> {
let layout = Layout {
from_engine: layout.from_engine,
from_element: layout.from_element.downcast_mut::<E::Layout>().unwrap(),
};
self.paint(layout, view, cx)
}
}
/// A dynamically typed element.
pub struct AnyElement<V> {
element: Box<dyn ElementObject<V>>,
layout: Option<(NodeId, Box<dyn Any>)>,
}
impl<V: 'static> AnyElement<V> {
pub fn layout(&mut self, view: &mut V, cx: &mut LayoutContext<V>) -> Result<NodeId> {
let pushed_text_style = self.push_text_style(cx);
let (node_id, layout) = self.element.layout(view, cx)?;
self.layout = Some((node_id, layout));
if pushed_text_style {
cx.pop_text_style();
}
Ok(node_id)
}
pub fn push_text_style(&mut self, cx: &mut impl RenderContext) -> bool {
let text_style = self.element.style().text_style();
if let Some(text_style) = text_style {
let mut current_text_style = cx.text_style();
text_style.apply(&mut current_text_style);
cx.push_text_style(current_text_style);
true
} else {
false
}
}
pub fn paint(&mut self, view: &mut V, cx: &mut PaintContext<V>) -> Result<()> {
let pushed_text_style = self.push_text_style(cx);
let (layout_node_id, element_layout) =
self.layout.as_mut().expect("paint called before layout");
let layout = Layout {
from_engine: cx
.layout_engine()
.unwrap()
.computed_layout(*layout_node_id)
.expect("make sure you're using this within a gpui2 adapter element"),
from_element: element_layout.as_mut(),
};
let style = self.element.style();
let fill_color = style.fill.flatten().and_then(|fill| fill.color());
if let Some(fill_color) = fill_color {
cx.scene.push_quad(gpui::scene::Quad {
bounds: layout.from_engine.bounds,
background: Some(fill_color.into()),
border: Default::default(),
corner_radii: Default::default(),
});
}
for event_handler in self.element.handlers_mut().iter().cloned() {
let EngineLayout { order, bounds } = layout.from_engine;
let view_id = cx.view_id();
let view_event_handler = event_handler.handler.clone();
cx.scene
.interactive_regions
.push(gpui::scene::InteractiveRegion {
order,
bounds,
outside_bounds: event_handler.outside_bounds,
event_handler: Rc::new(move |view, event, window_cx, view_id| {
let mut view_context = ViewContext::mutable(window_cx, view_id);
let mut event_context = EventContext::new(&mut view_context);
view_event_handler(
view.downcast_mut().unwrap(),
event,
&mut event_context,
);
}),
event_type: event_handler.event_type,
view_id,
});
}
self.element.paint(layout, view, cx)?;
if pushed_text_style {
cx.pop_text_style();
}
Ok(())
}
}
impl<V: 'static> Element<V> for AnyElement<V> {
type Layout = ();
fn declared_style(&mut self) -> &mut OptionalStyle {
self.element.style()
}
fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>> {
self.element.handlers_mut()
}
fn layout(
&mut self,
view: &mut V,
cx: &mut LayoutContext<V>,
) -> Result<(NodeId, Self::Layout)> {
Ok((self.layout(view, cx)?, ()))
}
fn paint(
&mut self,
layout: Layout<()>,
view: &mut V,
cx: &mut PaintContext<V>,
) -> Result<()> {
self.paint(view, cx)
}
}
pub trait IntoElement<V: 'static> {
type Element: Element<V>;
fn into_element(self) -> Self::Element;
fn into_any_element(self) -> AnyElement<V>
where
Self: Sized,
{
self.into_element().into_any()
}
}
}
mod frame {
use crate::{
element::{
AnyElement, Element, EventHandler, IntoElement, Layout, LayoutContext, NodeId,
PaintContext,
},
style::{OptionalStyle, Style},
};
use anyhow::{anyhow, Result};
use gpui::LayoutNodeId;
use gpui2_macros::IntoElement;
#[element_crate = "crate"]
pub struct Frame<V: 'static> {
style: OptionalStyle,
handlers: Vec<EventHandler<V>>,
children: Vec<AnyElement<V>>,
}
impl<V: 'static> crate::element::IntoElement<V> for Frame<V> {
type Element = Self;
fn into_element(self) -> Self {
self
}
}
pub fn frame<V>() -> Frame<V> {
Frame {
style: OptionalStyle::default(),
handlers: Vec::new(),
children: Vec::new(),
}
}
impl<V: 'static> Element<V> for Frame<V> {
type Layout = ();
fn declared_style(&mut self) -> &mut OptionalStyle {
&mut self.style
}
fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>> {
&mut self.handlers
}
fn layout(
&mut self,
view: &mut V,
cx: &mut LayoutContext<V>,
) -> Result<(NodeId, Self::Layout)> {
let child_layout_node_ids = self
.children
.iter_mut()
.map(|child| child.layout(view, cx))
.collect::<Result<Vec<LayoutNodeId>>>()?;
let rem_size = cx.rem_pixels();
let style: Style = self.style.into();
let node_id = cx
.layout_engine()
.ok_or_else(|| {
::anyhow::__private::must_use({
let error =
::anyhow::__private::format_err(format_args!("no layout engine"));
error
})
})?
.add_node(style.to_taffy(rem_size), child_layout_node_ids)?;
Ok((node_id, ()))
}
fn paint(
&mut self,
layout: Layout<()>,
view: &mut V,
cx: &mut PaintContext<V>,
) -> Result<()> {
for child in &mut self.children {
child.paint(view, cx)?;
}
Ok(())
}
}
impl<V: 'static> Frame<V> {
pub fn child(mut self, child: impl IntoElement<V>) -> Self {
self.children.push(child.into_any_element());
self
}
pub fn children<I, E>(mut self, children: I) -> Self
where
I: IntoIterator<Item = E>,
E: IntoElement<V>,
{
self.children
.extend(children.into_iter().map(|e| e.into_any_element()));
self
}
}
}
mod hoverable {
use crate::{
element::Element,
style::{OptionalStyle, Style},
};
use gpui::{
geometry::{rect::RectF, vector::Vector2F},
scene::MouseMove,
EngineLayout,
};
use std::{cell::Cell, marker::PhantomData, rc::Rc};
pub struct Hoverable<V, E> {
hover_style: OptionalStyle,
computed_style: Option<Style>,
view_type: PhantomData<V>,
child: E,
}
impl<V, E> Hoverable<V, E> {
pub fn new(child: E) -> Self {
Self {
hover_style: OptionalStyle::default(),
computed_style: None,
view_type: PhantomData,
child,
}
}
}
impl<V: 'static, E: Element<V>> Element<V> for Hoverable<V, E> {
type Layout = E::Layout;
fn declared_style(&mut self) -> &mut OptionalStyle {
&mut self.hover_style
}
fn computed_style(&mut self) -> &OptionalStyle {
::core::panicking::panic("not yet implemented")
}
fn handlers_mut(&mut self) -> &mut Vec<crate::element::EventHandler<V>> {
self.child.handlers_mut()
}
fn layout(
&mut self,
view: &mut V,
cx: &mut gpui::LayoutContext<V>,
) -> anyhow::Result<(taffy::tree::NodeId, Self::Layout)> {
self.child.layout(view, cx)
}
fn paint<'a>(
&mut self,
layout: crate::element::Layout<Self::Layout>,
view: &mut V,
cx: &mut crate::element::PaintContext<V>,
) -> anyhow::Result<()> {
let EngineLayout { bounds, order } = layout.from_engine;
let window_bounds = RectF::new(Vector2F::zero(), cx.window_size());
let was_hovered = Rc::new(Cell::new(false));
self.child.paint(layout, view, cx)?;
cx.draw_interactive_region(
order,
window_bounds,
false,
move |view, event: &MouseMove, cx| {
let is_hovered = bounds.contains_point(cx.mouse_position());
if is_hovered != was_hovered.get() {
was_hovered.set(is_hovered);
cx.repaint();
}
},
);
Ok(())
}
}
}
mod paint_context {
use derive_more::{Deref, DerefMut};
use gpui::{geometry::rect::RectF, EventContext, RenderContext, ViewContext};
pub use gpui::{LayoutContext, PaintContext as LegacyPaintContext};
use std::{any::TypeId, rc::Rc};
pub use taffy::tree::NodeId;
pub struct PaintContext<'a, 'b, 'c, 'd, V> {
#[deref]
#[deref_mut]
pub(crate) legacy_cx: &'d mut LegacyPaintContext<'a, 'b, 'c, V>,
pub(crate) scene: &'d mut gpui::SceneBuilder,
}
impl<'a, 'b, 'c, 'd, V> ::core::ops::Deref for PaintContext<'a, 'b, 'c, 'd, V> {
type Target = &'d mut LegacyPaintContext<'a, 'b, 'c, V>;
#[inline]
fn deref(&self) -> &Self::Target {
&self.legacy_cx
}
}
impl<'a, 'b, 'c, 'd, V> ::core::ops::DerefMut for PaintContext<'a, 'b, 'c, 'd, V> {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.legacy_cx
}
}
impl<V> RenderContext for PaintContext<'_, '_, '_, '_, V> {
fn text_style(&self) -> gpui::fonts::TextStyle {
self.legacy_cx.text_style()
}
fn push_text_style(&mut self, style: gpui::fonts::TextStyle) {
self.legacy_cx.push_text_style(style)
}
fn pop_text_style(&mut self) {
self.legacy_cx.pop_text_style()
}
}
impl<'a, 'b, 'c, 'd, V: 'static> PaintContext<'a, 'b, 'c, 'd, V> {
pub fn new(
legacy_cx: &'d mut LegacyPaintContext<'a, 'b, 'c, V>,
scene: &'d mut gpui::SceneBuilder,
) -> Self {
Self { legacy_cx, scene }
}
pub fn draw_interactive_region<E: 'static>(
&mut self,
order: u32,
bounds: RectF,
outside_bounds: bool,
event_handler: impl Fn(&mut V, &E, &mut EventContext<V>) + 'static,
) {
self.scene
.interactive_regions
.push(gpui::scene::InteractiveRegion {
order,
bounds,
outside_bounds,
event_handler: Rc::new(move |view, event, window_cx, view_id| {
let mut view_context = ViewContext::mutable(window_cx, view_id);
let mut event_context = EventContext::new(&mut view_context);
event_handler(
view.downcast_mut().unwrap(),
event.downcast_ref().unwrap(),
&mut event_context,
);
}),
event_type: TypeId::of::<E>(),
view_id: self.view_id(),
});
}
}
}
mod style {
use crate::color::Hsla;
use gpui::geometry::{
DefinedLength, Edges, Length, OptionalEdges, OptionalPoint, OptionalSize, Point, Size,
};
use optional::Optional;
pub use taffy::style::{
AlignContent, AlignItems, AlignSelf, Display, FlexDirection, FlexWrap, JustifyContent,
Overflow, Position,
};
pub struct Style {
/// What layout strategy should be used?
pub display: Display,
/// How children overflowing their container should affect layout
#[optional]
pub overflow: Point<Overflow>,
/// How much space (in points) should be reserved for the scrollbars of `Overflow::Scroll` and `Overflow::Auto` nodes.
pub scrollbar_width: f32,
/// What should the `position` value of this struct use as a base offset?
pub position: Position,
/// How should the position of this element be tweaked relative to the layout defined?
pub inset: Edges<Length>,
/// Sets the initial size of the item
#[optional]
pub size: Size<Length>,
/// Controls the minimum size of the item
#[optional]
pub min_size: Size<Length>,
/// Controls the maximum size of the item
#[optional]
pub max_size: Size<Length>,
/// Sets the preferred aspect ratio for the item. The ratio is calculated as width divided by height.
pub aspect_ratio: Option<f32>,
/// How large should the margin be on each side?
#[optional]
pub margin: Edges<Length>,
/// How large should the padding be on each side?
pub padding: Edges<DefinedLength>,
/// How large should the border be on each side?
pub border: Edges<DefinedLength>,
/// How this node's children aligned in the cross/block axis?
pub align_items: Option<AlignItems>,
/// How this node should be aligned in the cross/block axis. Falls back to the parents [`AlignItems`] if not set
pub align_self: Option<AlignSelf>,
/// How should content contained within this item be aligned in the cross/block axis
pub align_content: Option<AlignContent>,
/// How should contained within this item be aligned in the main/inline axis
pub justify_content: Option<JustifyContent>,
/// How large should the gaps between items in a flex container be?
pub gap: Size<DefinedLength>,
/// Which direction does the main axis flow in?
pub flex_direction: FlexDirection,
/// Should elements wrap, or stay in a single line?
pub flex_wrap: FlexWrap,
/// Sets the initial main axis size of the item
pub flex_basis: Length,
/// The relative rate at which this item grows when it is expanding to fill space, 0.0 is the default value, and this value must be positive.
pub flex_grow: f32,
/// The relative rate at which this item shrinks when it is contracting to fit into space, 1.0 is the default value, and this value must be positive.
pub flex_shrink: f32,
/// The fill color of this element
pub fill: Option<Fill>,
/// The color of text within this element. Cascades to children unless overridden.
pub text_color: Option<Hsla>,
}
#[automatically_derived]
impl ::core::clone::Clone for Style {
#[inline]
fn clone(&self) -> Style {
Style {
display: ::core::clone::Clone::clone(&self.display),
overflow: ::core::clone::Clone::clone(&self.overflow),
scrollbar_width: ::core::clone::Clone::clone(&self.scrollbar_width),
position: ::core::clone::Clone::clone(&self.position),
inset: ::core::clone::Clone::clone(&self.inset),
size: ::core::clone::Clone::clone(&self.size),
min_size: ::core::clone::Clone::clone(&self.min_size),
max_size: ::core::clone::Clone::clone(&self.max_size),
aspect_ratio: ::core::clone::Clone::clone(&self.aspect_ratio),
margin: ::core::clone::Clone::clone(&self.margin),
padding: ::core::clone::Clone::clone(&self.padding),
border: ::core::clone::Clone::clone(&self.border),
align_items: ::core::clone::Clone::clone(&self.align_items),
align_self: ::core::clone::Clone::clone(&self.align_self),
align_content: ::core::clone::Clone::clone(&self.align_content),
justify_content: ::core::clone::Clone::clone(&self.justify_content),
gap: ::core::clone::Clone::clone(&self.gap),
flex_direction: ::core::clone::Clone::clone(&self.flex_direction),
flex_wrap: ::core::clone::Clone::clone(&self.flex_wrap),
flex_basis: ::core::clone::Clone::clone(&self.flex_basis),
flex_grow: ::core::clone::Clone::clone(&self.flex_grow),
flex_shrink: ::core::clone::Clone::clone(&self.flex_shrink),
fill: ::core::clone::Clone::clone(&self.fill),
text_color: ::core::clone::Clone::clone(&self.text_color),
}
}
}
pub struct OptionalStyle {
pub display: Option<Display>,
pub overflow: OptionalPoint<Overflow>,
pub scrollbar_width: Option<f32>,
pub position: Option<Position>,
pub inset: Option<Edges<Length>>,
pub size: OptionalSize<Length>,
pub min_size: OptionalSize<Length>,
pub max_size: OptionalSize<Length>,
pub aspect_ratio: Option<Option<f32>>,
pub margin: OptionalEdges<Length>,
pub padding: Option<Edges<DefinedLength>>,
pub border: Option<Edges<DefinedLength>>,
pub align_items: Option<Option<AlignItems>>,
pub align_self: Option<Option<AlignSelf>>,
pub align_content: Option<Option<AlignContent>>,
pub justify_content: Option<Option<JustifyContent>>,
pub gap: Option<Size<DefinedLength>>,
pub flex_direction: Option<FlexDirection>,
pub flex_wrap: Option<FlexWrap>,
pub flex_basis: Option<Length>,
pub flex_grow: Option<f32>,
pub flex_shrink: Option<f32>,
pub fill: Option<Option<Fill>>,
pub text_color: Option<Option<Hsla>>,
}
#[automatically_derived]
impl ::core::default::Default for OptionalStyle {
#[inline]
fn default() -> OptionalStyle {
OptionalStyle {
display: ::core::default::Default::default(),
overflow: ::core::default::Default::default(),
scrollbar_width: ::core::default::Default::default(),
position: ::core::default::Default::default(),
inset: ::core::default::Default::default(),
size: ::core::default::Default::default(),
min_size: ::core::default::Default::default(),
max_size: ::core::default::Default::default(),
aspect_ratio: ::core::default::Default::default(),
margin: ::core::default::Default::default(),
padding: ::core::default::Default::default(),
border: ::core::default::Default::default(),
align_items: ::core::default::Default::default(),
align_self: ::core::default::Default::default(),
align_content: ::core::default::Default::default(),
justify_content: ::core::default::Default::default(),
gap: ::core::default::Default::default(),
flex_direction: ::core::default::Default::default(),
flex_wrap: ::core::default::Default::default(),
flex_basis: ::core::default::Default::default(),
flex_grow: ::core::default::Default::default(),
flex_shrink: ::core::default::Default::default(),
fill: ::core::default::Default::default(),
text_color: ::core::default::Default::default(),
}
}
}
#[automatically_derived]
impl ::core::clone::Clone for OptionalStyle {
#[inline]
fn clone(&self) -> OptionalStyle {
OptionalStyle {
display: ::core::clone::Clone::clone(&self.display),
overflow: ::core::clone::Clone::clone(&self.overflow),
scrollbar_width: ::core::clone::Clone::clone(&self.scrollbar_width),
position: ::core::clone::Clone::clone(&self.position),
inset: ::core::clone::Clone::clone(&self.inset),
size: ::core::clone::Clone::clone(&self.size),
min_size: ::core::clone::Clone::clone(&self.min_size),
max_size: ::core::clone::Clone::clone(&self.max_size),
aspect_ratio: ::core::clone::Clone::clone(&self.aspect_ratio),
margin: ::core::clone::Clone::clone(&self.margin),
padding: ::core::clone::Clone::clone(&self.padding),
border: ::core::clone::Clone::clone(&self.border),
align_items: ::core::clone::Clone::clone(&self.align_items),
align_self: ::core::clone::Clone::clone(&self.align_self),
align_content: ::core::clone::Clone::clone(&self.align_content),
justify_content: ::core::clone::Clone::clone(&self.justify_content),
gap: ::core::clone::Clone::clone(&self.gap),
flex_direction: ::core::clone::Clone::clone(&self.flex_direction),
flex_wrap: ::core::clone::Clone::clone(&self.flex_wrap),
flex_basis: ::core::clone::Clone::clone(&self.flex_basis),
flex_grow: ::core::clone::Clone::clone(&self.flex_grow),
flex_shrink: ::core::clone::Clone::clone(&self.flex_shrink),
fill: ::core::clone::Clone::clone(&self.fill),
text_color: ::core::clone::Clone::clone(&self.text_color),
}
}
}
impl Optional for OptionalStyle {
type Base = Style;
fn assign(&self, base: &mut Self::Base) {
if let Some(value) = self.display.clone() {
base.display = value;
}
if let Some(value) = self.overflow.clone() {
base.overflow = value;
}
if let Some(value) = self.scrollbar_width.clone() {
base.scrollbar_width = value;
}
if let Some(value) = self.position.clone() {
base.position = value;
}
if let Some(value) = self.inset.clone() {
base.inset = value;
}
if let Some(value) = self.size.clone() {
base.size = value;
}
if let Some(value) = self.min_size.clone() {
base.min_size = value;
}
if let Some(value) = self.max_size.clone() {
base.max_size = value;
}
if let Some(value) = self.aspect_ratio.clone() {
base.aspect_ratio = value;
}
if let Some(value) = self.margin.clone() {
base.margin = value;
}
if let Some(value) = self.padding.clone() {
base.padding = value;
}
if let Some(value) = self.border.clone() {
base.border = value;
}
if let Some(value) = self.align_items.clone() {
base.align_items = value;
}
if let Some(value) = self.align_self.clone() {
base.align_self = value;
}
if let Some(value) = self.align_content.clone() {
base.align_content = value;
}
if let Some(value) = self.justify_content.clone() {
base.justify_content = value;
}
if let Some(value) = self.gap.clone() {
base.gap = value;
}
if let Some(value) = self.flex_direction.clone() {
base.flex_direction = value;
}
if let Some(value) = self.flex_wrap.clone() {
base.flex_wrap = value;
}
if let Some(value) = self.flex_basis.clone() {
base.flex_basis = value;
}
if let Some(value) = self.flex_grow.clone() {
base.flex_grow = value;
}
if let Some(value) = self.flex_shrink.clone() {
base.flex_shrink = value;
}
if let Some(value) = self.fill.clone() {
base.fill = value;
}
if let Some(value) = self.text_color.clone() {
base.text_color = value;
}
}
}
impl From<OptionalStyle> for Style
where
Style: Default,
{
fn from(wrapper: OptionalStyle) -> Self {
let mut base = Self::default();
wrapper.assign(&mut base);
base
}
}
impl Style {
pub const DEFAULT: Style = Style {
display: Display::DEFAULT,
overflow: Point {
x: Overflow::Visible,
y: Overflow::Visible,
},
scrollbar_width: 0.0,
position: Position::Relative,
inset: Edges::auto(),
margin: Edges::<Length>::zero(),
padding: Edges::<DefinedLength>::zero(),
border: Edges::<DefinedLength>::zero(),
size: Size::auto(),
min_size: Size::auto(),
max_size: Size::auto(),
aspect_ratio: None,
gap: Size::zero(),
align_items: None,
align_self: None,
align_content: None,
justify_content: None,
flex_direction: FlexDirection::Row,
flex_wrap: FlexWrap::NoWrap,
flex_grow: 0.0,
flex_shrink: 1.0,
flex_basis: Length::Auto,
fill: None,
text_color: None,
};
pub fn new() -> Self {
Self::DEFAULT.clone()
}
pub fn to_taffy(&self, rem_size: f32) -> taffy::style::Style {
taffy::style::Style {
display: self.display,
overflow: self.overflow.clone().into(),
scrollbar_width: self.scrollbar_width,
position: self.position,
inset: self.inset.to_taffy(rem_size),
size: self.size.to_taffy(rem_size),
min_size: self.min_size.to_taffy(rem_size),
max_size: self.max_size.to_taffy(rem_size),
aspect_ratio: self.aspect_ratio,
margin: self.margin.to_taffy(rem_size),
padding: self.padding.to_taffy(rem_size),
border: self.border.to_taffy(rem_size),
align_items: self.align_items,
align_self: self.align_self,
align_content: self.align_content,
justify_content: self.justify_content,
gap: self.gap.to_taffy(rem_size),
flex_direction: self.flex_direction,
flex_wrap: self.flex_wrap,
flex_basis: self.flex_basis.to_taffy(rem_size).into(),
flex_grow: self.flex_grow,
flex_shrink: self.flex_shrink,
..Default::default()
}
}
}
impl Default for Style {
fn default() -> Self {
Self::DEFAULT.clone()
}
}
impl OptionalStyle {
pub fn text_style(&self) -> Option<OptionalTextStyle> {
self.text_color.map(|color| OptionalTextStyle { color })
}
}
pub struct OptionalTextStyle {
color: Option<Hsla>,
}
impl OptionalTextStyle {
pub fn apply(&self, style: &mut gpui::fonts::TextStyle) {
if let Some(color) = self.color {
style.color = color.into();
}
}
}
pub enum Fill {
Color(Hsla),
}
#[automatically_derived]
impl ::core::clone::Clone for Fill {
#[inline]
fn clone(&self) -> Fill {
match self {
Fill::Color(__self_0) => Fill::Color(::core::clone::Clone::clone(__self_0)),
}
}
}
impl Fill {
pub fn color(&self) -> Option<Hsla> {
match self {
Fill::Color(color) => Some(*color),
}
}
}
impl Default for Fill {
fn default() -> Self {
Self::Color(Hsla::default())
}
}
impl From<Hsla> for Fill {
fn from(color: Hsla) -> Self {
Self::Color(color)
}
}
}
mod text {
use crate::{
element::{Element, ElementMetadata, EventHandler, IntoElement},
style::Style,
};
use gpui::{geometry::Size, text_layout::LineLayout, RenderContext};
use parking_lot::Mutex;
use std::sync::Arc;
impl<V: 'static, S: Into<ArcCow<'static, str>>> IntoElement<V> for S {
type Element = Text<V>;
fn into_element(self) -> Self::Element {
Text {
text: self.into(),
metadata: Default::default(),
}
}
}
pub struct Text<V> {
text: ArcCow<'static, str>,
metadata: ElementMetadata<V>,
}
impl<V: 'static> Element<V> for Text<V> {
type Layout = Arc<Mutex<Option<TextLayout>>>;
fn declared_style(&mut self) -> &mut crate::style::OptionalStyle {
&mut self.metadata.style
}
fn layout(
&mut self,
view: &mut V,
cx: &mut gpui::LayoutContext<V>,
) -> anyhow::Result<(taffy::tree::NodeId, 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 = self.metadata.style.into();
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))
}
fn paint<'a>(
&mut self,
layout: crate::element::Layout<Arc<Mutex<Option<TextLayout>>>>,
view: &mut V,
cx: &mut crate::element::PaintContext<V>,
) -> anyhow::Result<()> {
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,
);
Ok(())
}
fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>> {
&mut self.metadata.handlers
}
}
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(),
}
}
}
}
mod themes {
use crate::color::{Hsla, Lerp};
use std::ops::Range;
pub mod rose_pine {
use crate::{
color::{hsla, rgb, Hsla},
ThemeColors,
};
use std::ops::Range;
pub struct RosePineThemes {
pub default: RosePinePalette,
pub dawn: RosePinePalette,
pub moon: RosePinePalette,
}
pub struct RosePinePalette {
pub base: Hsla,
pub surface: Hsla,
pub overlay: Hsla,
pub muted: Hsla,
pub subtle: Hsla,
pub text: Hsla,
pub love: Hsla,
pub gold: Hsla,
pub rose: Hsla,
pub pine: Hsla,
pub foam: Hsla,
pub iris: Hsla,
pub highlight_low: Hsla,
pub highlight_med: Hsla,
pub highlight_high: Hsla,
}
#[automatically_derived]
impl ::core::clone::Clone for RosePinePalette {
#[inline]
fn clone(&self) -> RosePinePalette {
let _: ::core::clone::AssertParamIsClone<Hsla>;
*self
}
}
#[automatically_derived]
impl ::core::marker::Copy for RosePinePalette {}
#[automatically_derived]
impl ::core::fmt::Debug for RosePinePalette {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
let names: &'static _ = &[
"base",
"surface",
"overlay",
"muted",
"subtle",
"text",
"love",
"gold",
"rose",
"pine",
"foam",
"iris",
"highlight_low",
"highlight_med",
"highlight_high",
];
let values: &[&dyn::core::fmt::Debug] = &[
&self.base,
&self.surface,
&self.overlay,
&self.muted,
&self.subtle,
&self.text,
&self.love,
&self.gold,
&self.rose,
&self.pine,
&self.foam,
&self.iris,
&self.highlight_low,
&self.highlight_med,
&&self.highlight_high,
];
::core::fmt::Formatter::debug_struct_fields_finish(
f,
"RosePinePalette",
names,
values,
)
}
}
impl RosePinePalette {
pub fn default() -> RosePinePalette {
RosePinePalette {
base: rgb(0x191724),
surface: rgb(0x1f1d2e),
overlay: rgb(0x26233a),
muted: rgb(0x6e6a86),
subtle: rgb(0x908caa),
text: rgb(0xe0def4),
love: rgb(0xeb6f92),
gold: rgb(0xf6c177),
rose: rgb(0xebbcba),
pine: rgb(0x31748f),
foam: rgb(0x9ccfd8),
iris: rgb(0xc4a7e7),
highlight_low: rgb(0x21202e),
highlight_med: rgb(0x403d52),
highlight_high: rgb(0x524f67),
}
}
pub fn moon() -> RosePinePalette {
RosePinePalette {
base: rgb(0x232136),
surface: rgb(0x2a273f),
overlay: rgb(0x393552),
muted: rgb(0x6e6a86),
subtle: rgb(0x908caa),
text: rgb(0xe0def4),
love: rgb(0xeb6f92),
gold: rgb(0xf6c177),
rose: rgb(0xea9a97),
pine: rgb(0x3e8fb0),
foam: rgb(0x9ccfd8),
iris: rgb(0xc4a7e7),
highlight_low: rgb(0x2a283e),
highlight_med: rgb(0x44415a),
highlight_high: rgb(0x56526e),
}
}
pub fn dawn() -> RosePinePalette {
RosePinePalette {
base: rgb(0xfaf4ed),
surface: rgb(0xfffaf3),
overlay: rgb(0xf2e9e1),
muted: rgb(0x9893a5),
subtle: rgb(0x797593),
text: rgb(0x575279),
love: rgb(0xb4637a),
gold: rgb(0xea9d34),
rose: rgb(0xd7827e),
pine: rgb(0x286983),
foam: rgb(0x56949f),
iris: rgb(0x907aa9),
highlight_low: rgb(0xf4ede8),
highlight_med: rgb(0xdfdad9),
highlight_high: rgb(0xcecacd),
}
}
}
pub fn default() -> ThemeColors {
theme_colors(&RosePinePalette::default())
}
pub fn moon() -> ThemeColors {
theme_colors(&RosePinePalette::moon())
}
pub fn dawn() -> ThemeColors {
theme_colors(&RosePinePalette::dawn())
}
fn theme_colors(p: &RosePinePalette) -> ThemeColors {
ThemeColors {
base: scale_sl(p.base, (0.8, 0.8), (1.2, 1.2)),
surface: scale_sl(p.surface, (0.8, 0.8), (1.2, 1.2)),
overlay: scale_sl(p.overlay, (0.8, 0.8), (1.2, 1.2)),
muted: scale_sl(p.muted, (0.8, 0.8), (1.2, 1.2)),
subtle: scale_sl(p.subtle, (0.8, 0.8), (1.2, 1.2)),
text: scale_sl(p.text, (0.8, 0.8), (1.2, 1.2)),
highlight_low: scale_sl(p.highlight_low, (0.8, 0.8), (1.2, 1.2)),
highlight_med: scale_sl(p.highlight_med, (0.8, 0.8), (1.2, 1.2)),
highlight_high: scale_sl(p.highlight_high, (0.8, 0.8), (1.2, 1.2)),
success: scale_sl(p.foam, (0.8, 0.8), (1.2, 1.2)),
warning: scale_sl(p.gold, (0.8, 0.8), (1.2, 1.2)),
error: scale_sl(p.love, (0.8, 0.8), (1.2, 1.2)),
inserted: scale_sl(p.foam, (0.8, 0.8), (1.2, 1.2)),
deleted: scale_sl(p.love, (0.8, 0.8), (1.2, 1.2)),
modified: scale_sl(p.rose, (0.8, 0.8), (1.2, 1.2)),
}
}
/// Produces a range by multiplying the saturation and lightness of the base color by the given
/// start and end factors.
fn scale_sl(
base: Hsla,
(start_s, start_l): (f32, f32),
(end_s, end_l): (f32, f32),
) -> Range<Hsla> {
let start = hsla(base.h, base.s * start_s, base.l * start_l, base.a);
let end = hsla(base.h, base.s * end_s, base.l * end_l, base.a);
Range { start, end }
}
}
pub struct ThemeColors {
pub base: Range<Hsla>,
pub surface: Range<Hsla>,
pub overlay: Range<Hsla>,
pub muted: Range<Hsla>,
pub subtle: Range<Hsla>,
pub text: Range<Hsla>,
pub highlight_low: Range<Hsla>,
pub highlight_med: Range<Hsla>,
pub highlight_high: Range<Hsla>,
pub success: Range<Hsla>,
pub warning: Range<Hsla>,
pub error: Range<Hsla>,
pub inserted: Range<Hsla>,
pub deleted: Range<Hsla>,
pub modified: Range<Hsla>,
}
impl ThemeColors {
pub fn base(&self, level: f32) -> Hsla {
self.base.lerp(level)
}
pub fn surface(&self, level: f32) -> Hsla {
self.surface.lerp(level)
}
pub fn overlay(&self, level: f32) -> Hsla {
self.overlay.lerp(level)
}
pub fn muted(&self, level: f32) -> Hsla {
self.muted.lerp(level)
}
pub fn subtle(&self, level: f32) -> Hsla {
self.subtle.lerp(level)
}
pub fn text(&self, level: f32) -> Hsla {
self.text.lerp(level)
}
pub fn highlight_low(&self, level: f32) -> Hsla {
self.highlight_low.lerp(level)
}
pub fn highlight_med(&self, level: f32) -> Hsla {
self.highlight_med.lerp(level)
}
pub fn highlight_high(&self, level: f32) -> Hsla {
self.highlight_high.lerp(level)
}
pub fn success(&self, level: f32) -> Hsla {
self.success.lerp(level)
}
pub fn warning(&self, level: f32) -> Hsla {
self.warning.lerp(level)
}
pub fn error(&self, level: f32) -> Hsla {
self.error.lerp(level)
}
pub fn inserted(&self, level: f32) -> Hsla {
self.inserted.lerp(level)
}
pub fn deleted(&self, level: f32) -> Hsla {
self.deleted.lerp(level)
}
pub fn modified(&self, level: f32) -> Hsla {
self.modified.lerp(level)
}
}
}
mod view {
use crate::element::{AnyElement, Element};
use gpui::{Element as _, ViewContext};
pub fn view<F, E>(mut render: F) -> ViewFn
where
F: 'static + FnMut(&mut ViewContext<ViewFn>) -> E,
E: Element<ViewFn>,
{
ViewFn(Box::new(move |cx| (render)(cx).into_any()))
}
pub struct ViewFn(Box<dyn FnMut(&mut ViewContext<ViewFn>) -> AnyElement<ViewFn>>);
impl gpui::Entity for ViewFn {
type Event = ();
}
impl gpui::View for ViewFn {
fn render(&mut self, cx: &mut ViewContext<Self>) -> gpui::AnyElement<Self> {
(self.0)(cx).adapt().into_any()
}
}
}
fn main() {
SimpleLogger::init(LevelFilter::Info, Default::default()).expect("could not initialize logger");
gpui::App::new(()).unwrap().run(|cx| {
cx.add_window(
WindowOptions {
bounds: gpui::platform::WindowBounds::Fixed(RectF::new(
vec2f(0., 0.),
vec2f(400., 300.),
)),
center: true,
..Default::default()
},
|_| view(|_| storybook(&rose_pine::moon())),
);
cx.platform().activate(true);
});
}
fn storybook<V: 'static>(theme: &ThemeColors) -> impl Element<V> {
frame()
.text_color(black())
.h_full()
.w_half()
.fill(theme.success(0.5))
.child(button().label("Hello").click(|_, _, _| {
::std::io::_print(format_args!("click!\n"));
}))
}
Reference in a new issue View git blame Copy permalink