Detailed changes
@@ -3271,36 +3271,6 @@ dependencies = [
"waker-fn",
]
-[[package]]
-name = "gpui2"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "derive_more",
- "futures 0.3.28",
- "gpui",
- "gpui2_macros",
- "log",
- "parking_lot 0.11.2",
- "refineable",
- "rust-embed",
- "serde",
- "settings",
- "simplelog",
- "smallvec",
- "theme",
- "util",
-]
-
-[[package]]
-name = "gpui2_macros"
-version = "0.1.0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
[[package]]
name = "gpui3"
version = "0.1.0"
@@ -34,8 +34,6 @@ members = [
"crates/go_to_line",
"crates/gpui",
"crates/gpui_macros",
- "crates/gpui2",
- "crates/gpui2_macros",
"crates/gpui3",
"crates/gpui3_macros",
"crates/install_cli",
@@ -1,32 +0,0 @@
-[package]
-name = "gpui2"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-name = "gpui2"
-path = "src/gpui2.rs"
-
-[features]
-test-support = ["gpui/test-support"]
-
-[dependencies]
-anyhow.workspace = true
-derive_more.workspace = true
-gpui = { path = "../gpui" }
-log.workspace = true
-futures.workspace = true
-gpui2_macros = { path = "../gpui2_macros" }
-parking_lot.workspace = true
-refineable.workspace = true
-rust-embed.workspace = true
-serde.workspace = true
-settings = { path = "../settings" }
-simplelog = "0.9"
-smallvec.workspace = true
-theme = { path = "../theme" }
-util = { path = "../util" }
-
-[dev-dependencies]
-gpui = { path = "../gpui", features = ["test-support"] }
@@ -1,76 +0,0 @@
-use crate::ViewContext;
-use gpui::{geometry::rect::RectF, LayoutEngine, LayoutId};
-use util::ResultExt;
-
-/// Makes a new, gpui2-style element into a legacy element.
-pub struct AdapterElement<V>(pub(crate) crate::element::AnyElement<V>);
-
-impl<V: 'static> gpui::Element<V> for AdapterElement<V> {
- type LayoutState = Option<(LayoutEngine, LayoutId)>;
- type PaintState = ();
-
- fn layout(
- &mut self,
- constraint: gpui::SizeConstraint,
- view: &mut V,
- cx: &mut gpui::ViewContext<V>,
- ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
- cx.push_layout_engine(LayoutEngine::new());
-
- let mut cx = ViewContext::new(cx);
- let layout_id = self.0.layout(view, &mut cx).log_err();
- if let Some(layout_id) = layout_id {
- cx.layout_engine()
- .unwrap()
- .compute_layout(layout_id, constraint.max)
- .log_err();
- }
-
- let layout_engine = cx.pop_layout_engine();
- debug_assert!(layout_engine.is_some(),
- "unexpected layout stack state. is there an unmatched pop_layout_engine in the called code?"
- );
-
- (constraint.max, layout_engine.zip(layout_id))
- }
-
- fn paint(
- &mut self,
- bounds: RectF,
- _visible_bounds: RectF,
- layout_data: &mut Option<(LayoutEngine, LayoutId)>,
- view: &mut V,
- cx: &mut gpui::ViewContext<V>,
- ) -> Self::PaintState {
- let (layout_engine, layout_id) = layout_data.take().unwrap();
- cx.push_layout_engine(layout_engine);
- self.0
- .paint(view, bounds.origin(), &mut ViewContext::new(cx));
- *layout_data = cx.pop_layout_engine().zip(Some(layout_id));
- debug_assert!(layout_data.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> {
- todo!("implement before merging to main")
- }
-
- fn debug(
- &self,
- _bounds: RectF,
- _layout: &Self::LayoutState,
- _paint: &Self::PaintState,
- _view: &V,
- _cx: &gpui::ViewContext<V>,
- ) -> gpui::serde_json::Value {
- todo!("implement before merging to main")
- }
-}
@@ -1,324 +0,0 @@
-#![allow(dead_code)]
-
-use serde::de::{self, Deserialize, Deserializer, Visitor};
-use smallvec::SmallVec;
-use std::fmt;
-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()
-}
-
-#[derive(Clone, Copy, Default, Debug)]
-pub struct Rgba {
- pub r: f32,
- pub g: f32,
- pub b: f32,
- pub a: f32,
-}
-
-struct RgbaVisitor;
-
-impl<'de> Visitor<'de> for RgbaVisitor {
- type Value = Rgba;
-
- fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter.write_str("a string in the format #rrggbb or #rrggbbaa")
- }
-
- fn visit_str<E: de::Error>(self, value: &str) -> Result<Rgba, E> {
- if value.len() == 7 || value.len() == 9 {
- let r = u8::from_str_radix(&value[1..3], 16).unwrap() as f32 / 255.0;
- let g = u8::from_str_radix(&value[3..5], 16).unwrap() as f32 / 255.0;
- let b = u8::from_str_radix(&value[5..7], 16).unwrap() as f32 / 255.0;
- let a = if value.len() == 9 {
- u8::from_str_radix(&value[7..9], 16).unwrap() as f32 / 255.0
- } else {
- 1.0
- };
- Ok(Rgba { r, g, b, a })
- } else {
- Err(E::custom(
- "Bad format for RGBA. Expected #rrggbb or #rrggbbaa.",
- ))
- }
- }
-}
-
-impl<'de> Deserialize<'de> for Rgba {
- fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
- deserializer.deserialize_str(RgbaVisitor)
- }
-}
-
-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)
- }
-}
-
-#[derive(Default, Copy, Clone, Debug, PartialEq)]
-pub struct Hsla {
- pub h: f32,
- pub s: f32,
- pub l: f32,
- pub a: f32,
-}
-
-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()
- }
-}
-
-impl<'de> Deserialize<'de> for Hsla {
- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where
- D: Deserializer<'de>,
- {
- // First, deserialize it into Rgba
- let rgba = Rgba::deserialize(deserializer)?;
-
- // Then, use the From<Rgba> for Hsla implementation to convert it
- Ok(Hsla::from(rgba))
- }
-}
-
-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 {
- // Ensure that the input is within [0.0, 1.0]
- debug_assert!(
- 0.0 <= t && t <= 1.0,
- "t value {} 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 }
- }
- }
- }
-}
@@ -1,232 +0,0 @@
-pub use crate::ViewContext;
-use anyhow::Result;
-use gpui::geometry::vector::Vector2F;
-pub use gpui::{Layout, LayoutId};
-use smallvec::SmallVec;
-
-pub trait Element<V: 'static>: 'static + IntoElement<V> {
- type PaintState;
-
- fn layout(
- &mut self,
- view: &mut V,
- cx: &mut ViewContext<V>,
- ) -> Result<(LayoutId, Self::PaintState)>
- where
- Self: Sized;
-
- fn paint(
- &mut self,
- view: &mut V,
- parent_origin: Vector2F,
- layout: &Layout,
- state: &mut Self::PaintState,
- cx: &mut ViewContext<V>,
- ) where
- Self: Sized;
-
- fn into_any(self) -> AnyElement<V>
- where
- Self: 'static + Sized,
- {
- AnyElement(Box::new(StatefulElement {
- element: self,
- phase: ElementPhase::Init,
- }))
- }
-
- /// Applies a given function `then` to the current element if `condition` is true.
- /// This function is used to conditionally modify the element based on a given condition.
- /// If `condition` is false, it just returns the current element as it is.
- ///
- /// # Parameters
- /// - `self`: The current element
- /// - `condition`: The boolean condition based on which `then` is applied to the element.
- /// - `then`: A function that takes in the current element and returns a possibly modified element.
- ///
- /// # Return
- /// It returns the potentially modified element.
- fn when(mut self, condition: bool, then: impl FnOnce(Self) -> Self) -> Self
- where
- Self: Sized,
- {
- if condition {
- self = then(self);
- }
- self
- }
-}
-
-/// Used to make ElementState<V, E> into a trait object, so we can wrap it in AnyElement<V>.
-trait AnyStatefulElement<V> {
- fn layout(&mut self, view: &mut V, cx: &mut ViewContext<V>) -> Result<LayoutId>;
- fn paint(&mut self, view: &mut V, parent_origin: Vector2F, cx: &mut ViewContext<V>);
-}
-
-/// A wrapper around an element that stores its layout state.
-struct StatefulElement<V: 'static, E: Element<V>> {
- element: E,
- phase: ElementPhase<V, E>,
-}
-
-enum ElementPhase<V: 'static, E: Element<V>> {
- Init,
- PostLayout {
- layout_id: LayoutId,
- paint_state: E::PaintState,
- },
- #[allow(dead_code)]
- PostPaint {
- layout: Layout,
- paint_state: E::PaintState,
- },
- Error(String),
-}
-
-impl<V: 'static, E: Element<V>> std::fmt::Debug for ElementPhase<V, E> {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- match self {
- ElementPhase::Init => write!(f, "Init"),
- ElementPhase::PostLayout { layout_id, .. } => {
- write!(f, "PostLayout with layout id: {:?}", layout_id)
- }
- ElementPhase::PostPaint { layout, .. } => {
- write!(f, "PostPaint with layout: {:?}", layout)
- }
- ElementPhase::Error(err) => write!(f, "Error: {}", err),
- }
- }
-}
-
-impl<V: 'static, E: Element<V>> Default for ElementPhase<V, E> {
- fn default() -> Self {
- Self::Init
- }
-}
-
-/// We blanket-implement the object-safe ElementStateObject interface to make ElementStates into trait objects
-impl<V, E: Element<V>> AnyStatefulElement<V> for StatefulElement<V, E> {
- fn layout(&mut self, view: &mut V, cx: &mut ViewContext<V>) -> Result<LayoutId> {
- let result;
- self.phase = match self.element.layout(view, cx) {
- Ok((layout_id, paint_state)) => {
- result = Ok(layout_id);
- ElementPhase::PostLayout {
- layout_id,
- paint_state,
- }
- }
- Err(error) => {
- let message = error.to_string();
- result = Err(error);
- ElementPhase::Error(message)
- }
- };
- result
- }
-
- fn paint(&mut self, view: &mut V, parent_origin: Vector2F, cx: &mut ViewContext<V>) {
- self.phase = match std::mem::take(&mut self.phase) {
- ElementPhase::PostLayout {
- layout_id,
- mut paint_state,
- } => match cx.computed_layout(layout_id) {
- Ok(layout) => {
- self.element
- .paint(view, parent_origin, &layout, &mut paint_state, cx);
- ElementPhase::PostPaint {
- layout,
- paint_state,
- }
- }
- Err(error) => ElementPhase::Error(error.to_string()),
- },
- ElementPhase::PostPaint {
- layout,
- mut paint_state,
- } => {
- self.element
- .paint(view, parent_origin, &layout, &mut paint_state, cx);
- ElementPhase::PostPaint {
- layout,
- paint_state,
- }
- }
- phase @ ElementPhase::Error(_) => phase,
-
- phase @ _ => {
- panic!("invalid element phase to call paint: {:?}", phase);
- }
- };
- }
-}
-
-/// A dynamic element.
-pub struct AnyElement<V>(Box<dyn AnyStatefulElement<V>>);
-
-impl<V> AnyElement<V> {
- pub fn layout(&mut self, view: &mut V, cx: &mut ViewContext<V>) -> Result<LayoutId> {
- self.0.layout(view, cx)
- }
-
- pub fn paint(&mut self, view: &mut V, parent_origin: Vector2F, cx: &mut ViewContext<V>) {
- self.0.paint(view, parent_origin, cx)
- }
-}
-
-pub trait ParentElement<V: 'static> {
- fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]>;
-
- fn child(mut self, child: impl IntoElement<V>) -> Self
- where
- Self: Sized,
- {
- self.children_mut().push(child.into_element().into_any());
- self
- }
-
- fn children<I, E>(mut self, children: I) -> Self
- where
- I: IntoIterator<Item = E>,
- E: IntoElement<V>,
- Self: Sized,
- {
- self.children_mut().extend(
- children
- .into_iter()
- .map(|child| child.into_element().into_any()),
- );
- self
- }
-
- // HACK: This is a temporary hack to get children working for the purposes
- // of building UI on top of the current version of gpui2.
- //
- // We'll (hopefully) be moving away from this in the future.
- fn children_any<I>(mut self, children: I) -> Self
- where
- I: IntoIterator<Item = AnyElement<V>>,
- Self: Sized,
- {
- self.children_mut().extend(children.into_iter());
- self
- }
-
- // HACK: This is a temporary hack to get children working for the purposes
- // of building UI on top of the current version of gpui2.
- //
- // We'll (hopefully) be moving away from this in the future.
- fn child_any(mut self, children: AnyElement<V>) -> Self
- where
- Self: Sized,
- {
- self.children_mut().push(children);
- self
- }
-}
-
-pub trait IntoElement<V: 'static> {
- type Element: Element<V>;
-
- fn into_element(self) -> Self::Element;
-}
@@ -1,10 +0,0 @@
-pub mod div;
-pub mod hoverable;
-mod img;
-pub mod pressable;
-pub mod svg;
-pub mod text;
-
-pub use div::div;
-pub use img::img;
-pub use svg::svg;
@@ -1,320 +0,0 @@
-use std::{cell::Cell, rc::Rc};
-
-use crate::{
- element::{AnyElement, Element, IntoElement, Layout, ParentElement},
- hsla,
- style::{CornerRadii, Overflow, Style, StyleHelpers, Styleable},
- InteractionHandlers, Interactive, ViewContext,
-};
-use anyhow::Result;
-use gpui::{
- geometry::{rect::RectF, vector::Vector2F, Point},
- platform::{MouseButton, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent},
- scene::{self},
- LayoutId,
-};
-use refineable::{Cascade, Refineable};
-use smallvec::SmallVec;
-use util::ResultExt;
-
-pub struct Div<V: 'static> {
- styles: Cascade<Style>,
- handlers: InteractionHandlers<V>,
- children: SmallVec<[AnyElement<V>; 2]>,
- scroll_state: Option<ScrollState>,
-}
-
-pub fn div<V>() -> Div<V> {
- Div {
- styles: Default::default(),
- handlers: Default::default(),
- children: Default::default(),
- scroll_state: None,
- }
-}
-
-impl<V: 'static> Element<V> for Div<V> {
- type PaintState = Vec<LayoutId>;
-
- fn layout(
- &mut self,
- view: &mut V,
- cx: &mut ViewContext<V>,
- ) -> Result<(LayoutId, Self::PaintState)>
- where
- Self: Sized,
- {
- let style = self.computed_style();
- let pop_text_style = style.text_style(cx).map_or(false, |style| {
- cx.push_text_style(&style).log_err().is_some()
- });
-
- let children = self
- .children
- .iter_mut()
- .map(|child| child.layout(view, cx))
- .collect::<Result<Vec<LayoutId>>>()?;
-
- if pop_text_style {
- cx.pop_text_style();
- }
-
- Ok((cx.add_layout_node(style, children.clone())?, children))
- }
-
- fn paint(
- &mut self,
- view: &mut V,
- parent_origin: Vector2F,
- layout: &Layout,
- child_layouts: &mut Vec<LayoutId>,
- cx: &mut ViewContext<V>,
- ) where
- Self: Sized,
- {
- let order = layout.order;
- let bounds = layout.bounds + parent_origin;
-
- let style = self.computed_style();
- let pop_text_style = style.text_style(cx).map_or(false, |style| {
- cx.push_text_style(&style).log_err().is_some()
- });
- style.paint_background(bounds, cx);
- self.interaction_handlers().paint(order, bounds, cx);
-
- let scrolled_origin = bounds.origin() - self.scroll_offset(&style.overflow);
-
- // TODO: Support only one dimension being hidden
- let mut pop_layer = false;
- if style.overflow.y != Overflow::Visible || style.overflow.x != Overflow::Visible {
- cx.scene().push_layer(Some(bounds));
- pop_layer = true;
- }
-
- for child in &mut self.children {
- child.paint(view, scrolled_origin, cx);
- }
-
- if pop_layer {
- cx.scene().pop_layer();
- }
-
- style.paint_foreground(bounds, cx);
- if pop_text_style {
- cx.pop_text_style();
- }
-
- self.handle_scroll(order, bounds, style.overflow.clone(), child_layouts, cx);
-
- if cx.is_inspector_enabled() {
- self.paint_inspector(parent_origin, layout, cx);
- }
- }
-}
-
-impl<V: 'static> Div<V> {
- pub fn overflow_hidden(mut self) -> Self {
- self.declared_style().overflow.x = Some(Overflow::Hidden);
- self.declared_style().overflow.y = Some(Overflow::Hidden);
- self
- }
-
- pub fn overflow_hidden_x(mut self) -> Self {
- self.declared_style().overflow.x = Some(Overflow::Hidden);
- self
- }
-
- pub fn overflow_hidden_y(mut self) -> Self {
- self.declared_style().overflow.y = Some(Overflow::Hidden);
- self
- }
-
- pub fn overflow_scroll(mut self, scroll_state: ScrollState) -> Self {
- self.scroll_state = Some(scroll_state);
- self.declared_style().overflow.x = Some(Overflow::Scroll);
- self.declared_style().overflow.y = Some(Overflow::Scroll);
- self
- }
-
- pub fn overflow_x_scroll(mut self, scroll_state: ScrollState) -> Self {
- self.scroll_state = Some(scroll_state);
- self.declared_style().overflow.x = Some(Overflow::Scroll);
- self
- }
-
- pub fn overflow_y_scroll(mut self, scroll_state: ScrollState) -> Self {
- self.scroll_state = Some(scroll_state);
- self.declared_style().overflow.y = Some(Overflow::Scroll);
- self
- }
-
- fn scroll_offset(&self, overflow: &Point<Overflow>) -> Vector2F {
- let mut offset = Vector2F::zero();
- if overflow.y == Overflow::Scroll {
- offset.set_y(self.scroll_state.as_ref().unwrap().y());
- }
- if overflow.x == Overflow::Scroll {
- offset.set_x(self.scroll_state.as_ref().unwrap().x());
- }
-
- offset
- }
-
- fn handle_scroll(
- &mut self,
- order: u32,
- bounds: RectF,
- overflow: Point<Overflow>,
- child_layout_ids: &[LayoutId],
- cx: &mut ViewContext<V>,
- ) {
- if overflow.y == Overflow::Scroll || overflow.x == Overflow::Scroll {
- let mut scroll_max = Vector2F::zero();
- for child_layout_id in child_layout_ids {
- if let Some(child_layout) = cx
- .layout_engine()
- .unwrap()
- .computed_layout(*child_layout_id)
- .log_err()
- {
- scroll_max = scroll_max.max(child_layout.bounds.lower_right());
- }
- }
- scroll_max -= bounds.size();
-
- let scroll_state = self.scroll_state.as_ref().unwrap().clone();
- cx.on_event(order, move |_, event: &ScrollWheelEvent, cx| {
- if bounds.contains_point(event.position) {
- let scroll_delta = match event.delta {
- gpui::platform::ScrollDelta::Pixels(delta) => delta,
- gpui::platform::ScrollDelta::Lines(delta) => {
- delta * cx.text_style().font_size
- }
- };
- if overflow.x == Overflow::Scroll {
- scroll_state.set_x(
- (scroll_state.x() - scroll_delta.x())
- .max(0.)
- .min(scroll_max.x()),
- );
- }
- if overflow.y == Overflow::Scroll {
- scroll_state.set_y(
- (scroll_state.y() - scroll_delta.y())
- .max(0.)
- .min(scroll_max.y()),
- );
- }
- cx.repaint();
- } else {
- cx.bubble_event();
- }
- })
- }
- }
-
- fn paint_inspector(&self, parent_origin: Vector2F, layout: &Layout, cx: &mut ViewContext<V>) {
- let style = self.styles.merged();
- let bounds = layout.bounds + parent_origin;
-
- let hovered = bounds.contains_point(cx.mouse_position());
- if hovered {
- let rem_size = cx.rem_size();
- cx.scene().push_quad(scene::Quad {
- bounds,
- background: Some(hsla(0., 0., 1., 0.05).into()),
- border: gpui::Border {
- color: hsla(0., 0., 1., 0.2).into(),
- top: 1.,
- right: 1.,
- bottom: 1.,
- left: 1.,
- },
- corner_radii: CornerRadii::default()
- .refined(&style.corner_radii)
- .to_gpui(bounds.size(), rem_size),
- })
- }
-
- let pressed = Cell::new(hovered && cx.is_mouse_down(MouseButton::Left));
- cx.on_event(layout.order, move |_, event: &MouseButtonEvent, _| {
- if bounds.contains_point(event.position) {
- if event.is_down {
- pressed.set(true);
- } else if pressed.get() {
- pressed.set(false);
- eprintln!("clicked div {:?} {:#?}", bounds, style);
- }
- }
- });
-
- let hovered = Cell::new(hovered);
- cx.on_event(layout.order, move |_, event: &MouseMovedEvent, cx| {
- cx.bubble_event();
- let hovered_now = bounds.contains_point(event.position);
- if hovered.get() != hovered_now {
- hovered.set(hovered_now);
- cx.repaint();
- }
- });
- }
-}
-
-impl<V> Styleable for Div<V> {
- type Style = Style;
-
- fn style_cascade(&mut self) -> &mut Cascade<Self::Style> {
- &mut self.styles
- }
-
- fn declared_style(&mut self) -> &mut <Self::Style as Refineable>::Refinement {
- self.styles.base()
- }
-}
-
-impl<V> StyleHelpers for Div<V> {}
-
-impl<V> Interactive<V> for Div<V> {
- fn interaction_handlers(&mut self) -> &mut InteractionHandlers<V> {
- &mut self.handlers
- }
-}
-
-impl<V: 'static> ParentElement<V> for Div<V> {
- fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
- &mut self.children
- }
-}
-
-impl<V: 'static> IntoElement<V> for Div<V> {
- type Element = Self;
-
- fn into_element(self) -> Self::Element {
- self
- }
-}
-
-#[derive(Default, Clone)]
-pub struct ScrollState(Rc<Cell<Vector2F>>);
-
-impl ScrollState {
- pub fn x(&self) -> f32 {
- self.0.get().x()
- }
-
- pub fn set_x(&self, value: f32) {
- let mut current_value = self.0.get();
- current_value.set_x(value);
- self.0.set(current_value);
- }
-
- pub fn y(&self) -> f32 {
- self.0.get().y()
- }
-
- pub fn set_y(&self, value: f32) {
- let mut current_value = self.0.get();
- current_value.set_y(value);
- self.0.set(current_value);
- }
-}
@@ -1,105 +0,0 @@
-use crate::{
- element::{AnyElement, Element, IntoElement, Layout, ParentElement},
- interactive::{InteractionHandlers, Interactive},
- style::{Style, StyleHelpers, Styleable},
- ViewContext,
-};
-use anyhow::Result;
-use gpui::{geometry::vector::Vector2F, platform::MouseMovedEvent, LayoutId};
-use refineable::{Cascade, CascadeSlot, Refineable};
-use smallvec::SmallVec;
-use std::{cell::Cell, rc::Rc};
-
-pub struct Hoverable<E: Styleable> {
- hovered: Rc<Cell<bool>>,
- cascade_slot: CascadeSlot,
- hovered_style: <E::Style as Refineable>::Refinement,
- child: E,
-}
-
-pub fn hoverable<E: Styleable>(mut child: E) -> Hoverable<E> {
- Hoverable {
- hovered: Rc::new(Cell::new(false)),
- cascade_slot: child.style_cascade().reserve(),
- hovered_style: Default::default(),
- child,
- }
-}
-
-impl<E: Styleable> Styleable for Hoverable<E> {
- type Style = E::Style;
-
- fn style_cascade(&mut self) -> &mut Cascade<Self::Style> {
- self.child.style_cascade()
- }
-
- fn declared_style(&mut self) -> &mut <Self::Style as Refineable>::Refinement {
- &mut self.hovered_style
- }
-}
-
-impl<V: 'static, E: Element<V> + Styleable> Element<V> for Hoverable<E> {
- type PaintState = E::PaintState;
-
- fn layout(
- &mut self,
- view: &mut V,
- cx: &mut ViewContext<V>,
- ) -> Result<(LayoutId, Self::PaintState)>
- where
- Self: Sized,
- {
- Ok(self.child.layout(view, cx)?)
- }
-
- fn paint(
- &mut self,
- view: &mut V,
- parent_origin: Vector2F,
- layout: &Layout,
- paint_state: &mut Self::PaintState,
- cx: &mut ViewContext<V>,
- ) where
- Self: Sized,
- {
- let bounds = layout.bounds + parent_origin;
- self.hovered.set(bounds.contains_point(cx.mouse_position()));
-
- let slot = self.cascade_slot;
- let style = self.hovered.get().then_some(self.hovered_style.clone());
- self.style_cascade().set(slot, style);
-
- let hovered = self.hovered.clone();
- cx.on_event(layout.order, move |_view, _: &MouseMovedEvent, cx| {
- cx.bubble_event();
- if bounds.contains_point(cx.mouse_position()) != hovered.get() {
- cx.repaint();
- }
- });
-
- self.child
- .paint(view, parent_origin, layout, paint_state, cx);
- }
-}
-
-impl<E: Styleable<Style = Style>> StyleHelpers for Hoverable<E> {}
-
-impl<V: 'static, E: Interactive<V> + Styleable> Interactive<V> for Hoverable<E> {
- fn interaction_handlers(&mut self) -> &mut InteractionHandlers<V> {
- self.child.interaction_handlers()
- }
-}
-
-impl<V: 'static, E: ParentElement<V> + Styleable> ParentElement<V> for Hoverable<E> {
- fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
- self.child.children_mut()
- }
-}
-
-impl<V: 'static, E: Element<V> + Styleable> IntoElement<V> for Hoverable<E> {
- type Element = Self;
-
- fn into_element(self) -> Self::Element {
- self
- }
-}
@@ -1,110 +0,0 @@
-use crate as gpui2;
-use crate::{
- style::{Style, StyleHelpers, Styleable},
- Element,
-};
-use futures::FutureExt;
-use gpui::geometry::vector::Vector2F;
-use gpui::scene;
-use gpui2_macros::IntoElement;
-use refineable::Cascade;
-use util::arc_cow::ArcCow;
-use util::ResultExt;
-
-#[derive(IntoElement)]
-pub struct Img {
- style: Cascade<Style>,
- uri: Option<ArcCow<'static, str>>,
-}
-
-pub fn img() -> Img {
- Img {
- style: Cascade::default(),
- uri: None,
- }
-}
-
-impl Img {
- pub fn uri(mut self, uri: impl Into<ArcCow<'static, str>>) -> Self {
- self.uri = Some(uri.into());
- self
- }
-}
-
-impl<V: 'static> Element<V> for Img {
- type PaintState = ();
-
- fn layout(
- &mut self,
- _: &mut V,
- cx: &mut crate::ViewContext<V>,
- ) -> anyhow::Result<(gpui::LayoutId, Self::PaintState)>
- where
- Self: Sized,
- {
- let style = self.computed_style();
- let layout_id = cx.add_layout_node(style, [])?;
- Ok((layout_id, ()))
- }
-
- fn paint(
- &mut self,
- _: &mut V,
- parent_origin: Vector2F,
- layout: &gpui::Layout,
- _: &mut Self::PaintState,
- cx: &mut crate::ViewContext<V>,
- ) where
- Self: Sized,
- {
- let style = self.computed_style();
- let bounds = layout.bounds + parent_origin;
-
- style.paint_background(bounds, cx);
-
- if let Some(uri) = &self.uri {
- let image_future = cx.image_cache.get(uri.clone());
- if let Some(data) = image_future
- .clone()
- .now_or_never()
- .and_then(ResultExt::log_err)
- {
- let rem_size = cx.rem_size();
- cx.scene().push_image(scene::Image {
- bounds,
- border: gpui::Border {
- color: style.border_color.unwrap_or_default().into(),
- top: style.border_widths.top.to_pixels(rem_size),
- right: style.border_widths.right.to_pixels(rem_size),
- bottom: style.border_widths.bottom.to_pixels(rem_size),
- left: style.border_widths.left.to_pixels(rem_size),
- },
- corner_radii: style.corner_radii.to_gpui(bounds.size(), rem_size),
- grayscale: false,
- data,
- })
- } else {
- cx.spawn(|this, mut cx| async move {
- if image_future.await.log_err().is_some() {
- this.update(&mut cx, |_, cx| cx.notify()).ok();
- }
- })
- .detach();
- }
- }
- }
-}
-
-impl Styleable for Img {
- type Style = Style;
-
- fn style_cascade(&mut self) -> &mut Cascade<Self::Style> {
- &mut self.style
- }
-
- fn declared_style(&mut self) -> &mut <Self::Style as refineable::Refineable>::Refinement {
- self.style.base()
- }
-}
-
-impl StyleHelpers for Img {}
@@ -1,113 +0,0 @@
-use crate::{
- element::{AnyElement, Element, IntoElement, Layout, ParentElement},
- interactive::{InteractionHandlers, Interactive},
- style::{Style, StyleHelpers, Styleable},
- ViewContext,
-};
-use anyhow::Result;
-use gpui::{geometry::vector::Vector2F, platform::MouseButtonEvent, LayoutId};
-use refineable::{Cascade, CascadeSlot, Refineable};
-use smallvec::SmallVec;
-use std::{cell::Cell, rc::Rc};
-
-pub struct Pressable<E: Styleable> {
- pressed: Rc<Cell<bool>>,
- pressed_style: <E::Style as Refineable>::Refinement,
- cascade_slot: CascadeSlot,
- child: E,
-}
-
-pub fn pressable<E: Styleable>(mut child: E) -> Pressable<E> {
- Pressable {
- pressed: Rc::new(Cell::new(false)),
- pressed_style: Default::default(),
- cascade_slot: child.style_cascade().reserve(),
- child,
- }
-}
-
-impl<E: Styleable> Styleable for Pressable<E> {
- type Style = E::Style;
-
- fn declared_style(&mut self) -> &mut <Self::Style as Refineable>::Refinement {
- &mut self.pressed_style
- }
-
- fn style_cascade(&mut self) -> &mut Cascade<E::Style> {
- self.child.style_cascade()
- }
-}
-
-impl<V: 'static, E: Element<V> + Styleable> Element<V> for Pressable<E> {
- type PaintState = E::PaintState;
-
- fn layout(
- &mut self,
- view: &mut V,
- cx: &mut ViewContext<V>,
- ) -> Result<(LayoutId, Self::PaintState)>
- where
- Self: Sized,
- {
- self.child.layout(view, cx)
- }
-
- fn paint(
- &mut self,
- view: &mut V,
- parent_origin: Vector2F,
- layout: &Layout,
- paint_state: &mut Self::PaintState,
- cx: &mut ViewContext<V>,
- ) where
- Self: Sized,
- {
- let slot = self.cascade_slot;
- let style = self.pressed.get().then_some(self.pressed_style.clone());
- self.style_cascade().set(slot, style);
-
- let pressed = self.pressed.clone();
- let bounds = layout.bounds + parent_origin;
- cx.on_event(layout.order, move |_view, event: &MouseButtonEvent, cx| {
- if event.is_down {
- if bounds.contains_point(event.position) {
- pressed.set(true);
- cx.repaint();
- } else {
- cx.bubble_event();
- }
- } else {
- if pressed.get() {
- pressed.set(false);
- cx.repaint();
- }
- cx.bubble_event();
- }
- });
-
- self.child
- .paint(view, parent_origin, layout, paint_state, cx);
- }
-}
-
-impl<E: Styleable<Style = Style>> StyleHelpers for Pressable<E> {}
-
-impl<V: 'static, E: Interactive<V> + Styleable> Interactive<V> for Pressable<E> {
- fn interaction_handlers(&mut self) -> &mut InteractionHandlers<V> {
- self.child.interaction_handlers()
- }
-}
-
-impl<V: 'static, E: ParentElement<V> + Styleable> ParentElement<V> for Pressable<E> {
- fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
- self.child.children_mut()
- }
-}
-
-impl<V: 'static, E: Element<V> + Styleable> IntoElement<V> for Pressable<E> {
- type Element = Self;
-
- fn into_element(self) -> Self::Element {
- self
- }
-}
@@ -1,84 +0,0 @@
-use crate::{
- self as gpui2, scene,
- style::{Style, StyleHelpers, Styleable},
- Element, IntoElement, Layout, LayoutId, Rgba,
-};
-use gpui::geometry::vector::Vector2F;
-use refineable::Cascade;
-use std::borrow::Cow;
-use util::ResultExt;
-
-#[derive(IntoElement)]
-pub struct Svg {
- path: Option<Cow<'static, str>>,
- style: Cascade<Style>,
-}
-
-pub fn svg() -> Svg {
- Svg {
- path: None,
- style: Cascade::<Style>::default(),
- }
-}
-
-impl Svg {
- pub fn path(mut self, path: impl Into<Cow<'static, str>>) -> Self {
- self.path = Some(path.into());
- self
- }
-}
-
-impl<V: 'static> Element<V> for Svg {
- type PaintState = ();
-
- fn layout(
- &mut self,
- _: &mut V,
- cx: &mut crate::ViewContext<V>,
- ) -> anyhow::Result<(LayoutId, Self::PaintState)>
- where
- Self: Sized,
- {
- let style = self.computed_style();
- Ok((cx.add_layout_node(style, [])?, ()))
- }
-
- fn paint(
- &mut self,
- _: &mut V,
- parent_origin: Vector2F,
- layout: &Layout,
- _: &mut Self::PaintState,
- cx: &mut crate::ViewContext<V>,
- ) where
- Self: Sized,
- {
- let fill_color = self.computed_style().fill.and_then(|fill| fill.color());
- if let Some((path, fill_color)) = self.path.as_ref().zip(fill_color) {
- if let Some(svg_tree) = cx.asset_cache.svg(path).log_err() {
- let icon = scene::Icon {
- bounds: layout.bounds + parent_origin,
- svg: svg_tree,
- path: path.clone(),
- color: Rgba::from(fill_color).into(),
- };
-
- cx.scene().push_icon(icon);
- }
- }
- }
-}
-
-impl Styleable for Svg {
- type Style = Style;
-
- fn style_cascade(&mut self) -> &mut refineable::Cascade<Self::Style> {
- &mut self.style
- }
-
- fn declared_style(&mut self) -> &mut <Self::Style as refineable::Refineable>::Refinement {
- self.style.base()
- }
-}
-
-impl StyleHelpers for Svg {}
@@ -1,105 +0,0 @@
-use crate::{
- element::{Element, IntoElement, Layout},
- ViewContext,
-};
-use anyhow::Result;
-use gpui::{
- geometry::{vector::Vector2F, Size},
- text_layout::Line,
- LayoutId,
-};
-use parking_lot::Mutex;
-use std::sync::Arc;
-use util::arc_cow::ArcCow;
-
-impl<V: 'static, S: Into<ArcCow<'static, str>>> IntoElement<V> for S {
- type Element = Text;
-
- fn into_element(self) -> Self::Element {
- Text { text: self.into() }
- }
-}
-
-pub struct Text {
- text: ArcCow<'static, str>,
-}
-
-impl<V: 'static> Element<V> for Text {
- type PaintState = Arc<Mutex<Option<TextLayout>>>;
-
- fn layout(
- &mut self,
- _view: &mut V,
- cx: &mut ViewContext<V>,
- ) -> Result<(LayoutId, Self::PaintState)> {
- let layout_cache = cx.text_layout_cache().clone();
- let text_style = cx.text_style();
- let line_height = cx.font_cache().line_height(text_style.font_size);
- let text = self.text.clone();
- let paint_state = Arc::new(Mutex::new(None));
-
- let layout_id = cx.add_measured_layout_node(Default::default(), {
- let paint_state = paint_state.clone();
- move |_params| {
- let line_layout = layout_cache.layout_str(
- text.as_ref(),
- text_style.font_size,
- &[(text.len(), text_style.to_run())],
- );
-
- let size = Size {
- width: line_layout.width(),
- height: line_height,
- };
-
- paint_state.lock().replace(TextLayout {
- line_layout: Arc::new(line_layout),
- line_height,
- });
-
- size
- }
- });
-
- Ok((layout_id?, paint_state))
- }
-
- fn paint<'a>(
- &mut self,
- _view: &mut V,
- parent_origin: Vector2F,
- layout: &Layout,
- paint_state: &mut Self::PaintState,
- cx: &mut ViewContext<V>,
- ) {
- let bounds = layout.bounds + parent_origin;
-
- let line_layout;
- let line_height;
- {
- let paint_state = paint_state.lock();
- let paint_state = paint_state
- .as_ref()
- .expect("measurement has not been performed");
- line_layout = paint_state.line_layout.clone();
- line_height = paint_state.line_height;
- }
-
- // TODO: We haven't added visible bounds to the new element system yet, so this is a placeholder.
- let visible_bounds = bounds;
- line_layout.paint(bounds.origin(), visible_bounds, line_height, cx.legacy_cx);
- }
-}
-
-impl<V: 'static> IntoElement<V> for Text {
- type Element = Self;
-
- fn into_element(self) -> Self::Element {
- self
- }
-}
-
-pub struct TextLayout {
- line_layout: Arc<Line>,
- line_height: f32,
-}
@@ -1,22 +0,0 @@
-pub mod adapter;
-pub mod color;
-pub mod element;
-pub mod elements;
-pub mod interactive;
-pub mod style;
-pub mod view;
-pub mod view_context;
-
-pub use color::*;
-pub use element::{AnyElement, Element, IntoElement, Layout, ParentElement};
-pub use geometry::{
- rect::RectF,
- vector::{vec2f, Vector2F},
-};
-pub use gpui::*;
-pub use gpui2_macros::{Element, *};
-pub use interactive::*;
-pub use platform::{Platform, WindowBounds, WindowOptions};
-pub use util::arc_cow::ArcCow;
-pub use view::*;
-pub use view_context::ViewContext;
@@ -1,165 +0,0 @@
-use gpui::{
- geometry::rect::RectF,
- platform::{MouseButton, MouseButtonEvent},
- EventContext,
-};
-use smallvec::SmallVec;
-use std::{cell::Cell, rc::Rc};
-
-use crate::ViewContext;
-
-pub trait Interactive<V: 'static> {
- fn interaction_handlers(&mut self) -> &mut InteractionHandlers<V>;
-
- fn on_mouse_down(
- mut self,
- button: MouseButton,
- handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- self.interaction_handlers()
- .mouse_down
- .push(Rc::new(move |view, event, cx| {
- if event.button == button {
- handler(view, event, cx)
- }
- }));
- self
- }
-
- fn on_mouse_up(
- mut self,
- button: MouseButton,
- handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- self.interaction_handlers()
- .mouse_up
- .push(Rc::new(move |view, event, cx| {
- if event.button == button {
- handler(view, event, cx)
- }
- }));
- self
- }
-
- fn on_mouse_down_out(
- mut self,
- button: MouseButton,
- handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- self.interaction_handlers()
- .mouse_down_out
- .push(Rc::new(move |view, event, cx| {
- if event.button == button {
- handler(view, event, cx)
- }
- }));
- self
- }
-
- fn on_mouse_up_out(
- mut self,
- button: MouseButton,
- handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- self.interaction_handlers()
- .mouse_up_out
- .push(Rc::new(move |view, event, cx| {
- if event.button == button {
- handler(view, event, cx)
- }
- }));
- self
- }
-
- fn on_click(
- self,
- button: MouseButton,
- handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- let pressed = Rc::new(Cell::new(false));
- self.on_mouse_down(button, {
- let pressed = pressed.clone();
- move |_, _, _| {
- pressed.set(true);
- }
- })
- .on_mouse_up_out(button, {
- let pressed = pressed.clone();
- move |_, _, _| {
- pressed.set(false);
- }
- })
- .on_mouse_up(button, move |view, event, cx| {
- if pressed.get() {
- pressed.set(false);
- handler(view, event, cx);
- }
- })
- }
-}
-
-pub struct InteractionHandlers<V: 'static> {
- mouse_down: SmallVec<[Rc<dyn Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>)>; 2]>,
- mouse_down_out: SmallVec<[Rc<dyn Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>)>; 2]>,
- mouse_up: SmallVec<[Rc<dyn Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>)>; 2]>,
- mouse_up_out: SmallVec<[Rc<dyn Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>)>; 2]>,
-}
-
-impl<V: 'static> InteractionHandlers<V> {
- pub fn paint(&self, order: u32, bounds: RectF, cx: &mut ViewContext<V>) {
- for handler in self.mouse_down.iter().cloned() {
- cx.on_event(order, move |view, event: &MouseButtonEvent, cx| {
- if event.is_down && bounds.contains_point(event.position) {
- handler(view, event, cx);
- }
- })
- }
- for handler in self.mouse_up.iter().cloned() {
- cx.on_event(order, move |view, event: &MouseButtonEvent, cx| {
- if !event.is_down && bounds.contains_point(event.position) {
- handler(view, event, cx);
- }
- })
- }
- for handler in self.mouse_down_out.iter().cloned() {
- cx.on_event(order, move |view, event: &MouseButtonEvent, cx| {
- if event.is_down && !bounds.contains_point(event.position) {
- handler(view, event, cx);
- }
- })
- }
- for handler in self.mouse_up_out.iter().cloned() {
- cx.on_event(order, move |view, event: &MouseButtonEvent, cx| {
- if !event.is_down && !bounds.contains_point(event.position) {
- handler(view, event, cx);
- }
- })
- }
- }
-}
-
-impl<V> Default for InteractionHandlers<V> {
- fn default() -> Self {
- Self {
- mouse_down: Default::default(),
- mouse_up: Default::default(),
- mouse_down_out: Default::default(),
- mouse_up_out: Default::default(),
- }
- }
-}
@@ -1,498 +0,0 @@
-use crate::{
- color::Hsla,
- elements::hoverable::{hoverable, Hoverable},
- elements::pressable::{pressable, Pressable},
- ViewContext,
-};
-pub use fonts::Style as FontStyle;
-pub use fonts::Weight as FontWeight;
-pub use gpui::taffy::style::{
- AlignContent, AlignItems, AlignSelf, Display, FlexDirection, FlexWrap, JustifyContent,
- Overflow, Position,
-};
-use gpui::{
- fonts::{self, TextStyleRefinement},
- geometry::{
- rect::RectF, relative, vector::Vector2F, AbsoluteLength, DefiniteLength, Edges,
- EdgesRefinement, Length, Point, PointRefinement, Size, SizeRefinement,
- },
- scene, taffy, WindowContext,
-};
-use gpui2_macros::styleable_helpers;
-use refineable::{Cascade, Refineable};
-use std::sync::Arc;
-
-#[derive(Clone, Refineable, Debug)]
-#[refineable(debug)]
-pub struct Style {
- /// What layout strategy should be used?
- pub display: Display,
-
- // Overflow properties
- /// How children overflowing their container should affect layout
- #[refineable]
- 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,
-
- // Position properties
- /// 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?
- #[refineable]
- pub inset: Edges<Length>,
-
- // Size properies
- /// Sets the initial size of the item
- #[refineable]
- pub size: Size<Length>,
- /// Controls the minimum size of the item
- #[refineable]
- pub min_size: Size<Length>,
- /// Controls the maximum size of the item
- #[refineable]
- 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>,
-
- // Spacing Properties
- /// How large should the margin be on each side?
- #[refineable]
- pub margin: Edges<Length>,
- /// How large should the padding be on each side?
- #[refineable]
- pub padding: Edges<DefiniteLength>,
- /// How large should the border be on each side?
- #[refineable]
- pub border_widths: Edges<AbsoluteLength>,
-
- // Alignment properties
- /// 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?
- #[refineable]
- pub gap: Size<DefiniteLength>,
-
- // Flexbox properies
- /// 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 border color of this element
- pub border_color: Option<Hsla>,
-
- /// The radius of the corners of this element
- #[refineable]
- pub corner_radii: CornerRadii,
-
- /// The color of text within this element. Cascades to children unless overridden.
- pub text_color: Option<Hsla>,
-
- /// The font size in rems.
- pub font_size: Option<f32>,
-
- pub font_family: Option<Arc<str>>,
-
- pub font_weight: Option<FontWeight>,
-
- pub font_style: Option<FontStyle>,
-}
-
-impl Style {
- pub fn text_style(&self, cx: &WindowContext) -> Option<TextStyleRefinement> {
- if self.text_color.is_none()
- && self.font_size.is_none()
- && self.font_family.is_none()
- && self.font_weight.is_none()
- && self.font_style.is_none()
- {
- return None;
- }
-
- Some(TextStyleRefinement {
- color: self.text_color.map(Into::into),
- font_family: self.font_family.clone(),
- font_size: self.font_size.map(|size| size * cx.rem_size()),
- font_weight: self.font_weight,
- font_style: self.font_style,
- underline: None,
- })
- }
-
- 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_widths.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() // Ignore grid properties for now
- }
- }
-
- /// Paints the background of an element styled with this style.
- pub fn paint_background<V: 'static>(&self, bounds: RectF, cx: &mut ViewContext<V>) {
- let rem_size = cx.rem_size();
- if let Some(color) = self.fill.as_ref().and_then(Fill::color) {
- cx.scene().push_quad(gpui::Quad {
- bounds,
- background: Some(color.into()),
- corner_radii: self.corner_radii.to_gpui(bounds.size(), rem_size),
- border: Default::default(),
- });
- }
- }
-
- /// Paints the foreground of an element styled with this style.
- pub fn paint_foreground<V: 'static>(&self, bounds: RectF, cx: &mut ViewContext<V>) {
- let rem_size = cx.rem_size();
-
- if let Some(color) = self.border_color {
- let border = self.border_widths.to_pixels(rem_size);
- if !border.is_empty() {
- cx.scene().push_quad(gpui::Quad {
- bounds,
- background: None,
- corner_radii: self.corner_radii.to_gpui(bounds.size(), rem_size),
- border: scene::Border {
- color: color.into(),
- top: border.top,
- right: border.right,
- bottom: border.bottom,
- left: border.left,
- },
- });
- }
- }
- }
-}
-
-impl Default for Style {
- fn default() -> Self {
- Style {
- display: Display::Block,
- overflow: Point {
- x: Overflow::Visible,
- y: Overflow::Visible,
- },
- scrollbar_width: 0.0,
- position: Position::Relative,
- inset: Edges::auto(),
- margin: Edges::<Length>::zero(),
- padding: Edges::<DefiniteLength>::zero(),
- border_widths: Edges::<AbsoluteLength>::zero(),
- size: Size::auto(),
- min_size: Size::auto(),
- max_size: Size::auto(),
- aspect_ratio: None,
- gap: Size::zero(),
- // Aligment
- align_items: None,
- align_self: None,
- align_content: None,
- justify_content: None,
- // Flexbox
- flex_direction: FlexDirection::Row,
- flex_wrap: FlexWrap::NoWrap,
- flex_grow: 0.0,
- flex_shrink: 1.0,
- flex_basis: Length::Auto,
- fill: None,
- border_color: None,
- corner_radii: CornerRadii::default(),
- text_color: None,
- font_size: Some(1.),
- font_family: None,
- font_weight: None,
- font_style: None,
- }
- }
-}
-
-#[derive(Clone, Debug)]
-pub enum Fill {
- Color(Hsla),
-}
-
-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)
- }
-}
-
-#[derive(Clone, Refineable, Default, Debug)]
-#[refineable(debug)]
-pub struct CornerRadii {
- top_left: AbsoluteLength,
- top_right: AbsoluteLength,
- bottom_left: AbsoluteLength,
- bottom_right: AbsoluteLength,
-}
-
-impl CornerRadii {
- pub fn to_gpui(&self, box_size: Vector2F, rem_size: f32) -> gpui::scene::CornerRadii {
- let max_radius = box_size.x().min(box_size.y()) / 2.;
-
- gpui::scene::CornerRadii {
- top_left: self.top_left.to_pixels(rem_size).min(max_radius),
- top_right: self.top_right.to_pixels(rem_size).min(max_radius),
- bottom_left: self.bottom_left.to_pixels(rem_size).min(max_radius),
- bottom_right: self.bottom_right.to_pixels(rem_size).min(max_radius),
- }
- }
-}
-
-pub trait Styleable {
- type Style: Refineable + Default;
-
- fn style_cascade(&mut self) -> &mut Cascade<Self::Style>;
- fn declared_style(&mut self) -> &mut <Self::Style as Refineable>::Refinement;
-
- fn computed_style(&mut self) -> Self::Style {
- Self::Style::from_refinement(&self.style_cascade().merged())
- }
-
- fn hover(self) -> Hoverable<Self>
- where
- Self: Sized,
- {
- hoverable(self)
- }
-
- fn active(self) -> Pressable<Self>
- where
- Self: Sized,
- {
- pressable(self)
- }
-}
-
-use crate as gpui2;
-
-// Helpers methods that take and return mut self. This includes tailwind style methods for standard sizes etc.
-//
-// Example:
-// // Sets the padding to 0.5rem, just like class="p-2" in Tailwind.
-// fn p_2(mut self) -> Self;
-pub trait StyleHelpers: Sized + Styleable<Style = Style> {
- styleable_helpers!();
-
- fn full(mut self) -> Self {
- self.declared_style().size.width = Some(relative(1.).into());
- self.declared_style().size.height = Some(relative(1.).into());
- self
- }
-
- fn relative(mut self) -> Self {
- self.declared_style().position = Some(Position::Relative);
- self
- }
-
- fn absolute(mut self) -> Self {
- self.declared_style().position = Some(Position::Absolute);
- self
- }
-
- fn block(mut self) -> Self {
- self.declared_style().display = Some(Display::Block);
- self
- }
-
- fn flex(mut self) -> Self {
- self.declared_style().display = Some(Display::Flex);
- self
- }
-
- fn flex_col(mut self) -> Self {
- self.declared_style().flex_direction = Some(FlexDirection::Column);
- self
- }
-
- fn flex_row(mut self) -> Self {
- self.declared_style().flex_direction = Some(FlexDirection::Row);
- self
- }
-
- fn flex_1(mut self) -> Self {
- self.declared_style().flex_grow = Some(1.);
- self.declared_style().flex_shrink = Some(1.);
- self.declared_style().flex_basis = Some(relative(0.).into());
- self
- }
-
- fn flex_auto(mut self) -> Self {
- self.declared_style().flex_grow = Some(1.);
- self.declared_style().flex_shrink = Some(1.);
- self.declared_style().flex_basis = Some(Length::Auto);
- self
- }
-
- fn flex_initial(mut self) -> Self {
- self.declared_style().flex_grow = Some(0.);
- self.declared_style().flex_shrink = Some(1.);
- self.declared_style().flex_basis = Some(Length::Auto);
- self
- }
-
- fn flex_none(mut self) -> Self {
- self.declared_style().flex_grow = Some(0.);
- self.declared_style().flex_shrink = Some(0.);
- self
- }
-
- fn grow(mut self) -> Self {
- self.declared_style().flex_grow = Some(1.);
- self
- }
-
- fn items_start(mut self) -> Self {
- self.declared_style().align_items = Some(AlignItems::FlexStart);
- self
- }
-
- fn items_end(mut self) -> Self {
- self.declared_style().align_items = Some(AlignItems::FlexEnd);
- self
- }
-
- fn items_center(mut self) -> Self {
- self.declared_style().align_items = Some(AlignItems::Center);
- self
- }
-
- fn justify_between(mut self) -> Self {
- self.declared_style().justify_content = Some(JustifyContent::SpaceBetween);
- self
- }
-
- fn justify_center(mut self) -> Self {
- self.declared_style().justify_content = Some(JustifyContent::Center);
- self
- }
-
- fn justify_start(mut self) -> Self {
- self.declared_style().justify_content = Some(JustifyContent::Start);
- self
- }
-
- fn justify_end(mut self) -> Self {
- self.declared_style().justify_content = Some(JustifyContent::End);
- self
- }
-
- fn justify_around(mut self) -> Self {
- self.declared_style().justify_content = Some(JustifyContent::SpaceAround);
- self
- }
-
- fn fill<F>(mut self, fill: F) -> Self
- where
- F: Into<Fill>,
- {
- self.declared_style().fill = Some(fill.into());
- self
- }
-
- fn border_color<C>(mut self, border_color: C) -> Self
- where
- C: Into<Hsla>,
- {
- self.declared_style().border_color = Some(border_color.into());
- self
- }
-
- fn text_color<C>(mut self, color: C) -> Self
- where
- C: Into<Hsla>,
- {
- self.declared_style().text_color = Some(color.into());
- self
- }
-
- fn text_xs(mut self) -> Self {
- self.declared_style().font_size = Some(0.75);
- self
- }
-
- fn text_sm(mut self) -> Self {
- self.declared_style().font_size = Some(0.875);
- self
- }
-
- fn text_base(mut self) -> Self {
- self.declared_style().font_size = Some(1.0);
- self
- }
-
- fn text_lg(mut self) -> Self {
- self.declared_style().font_size = Some(1.125);
- self
- }
-
- fn text_xl(mut self) -> Self {
- self.declared_style().font_size = Some(1.25);
- self
- }
-
- fn text_2xl(mut self) -> Self {
- self.declared_style().font_size = Some(1.5);
- self
- }
-
- fn text_3xl(mut self) -> Self {
- self.declared_style().font_size = Some(1.875);
- self
- }
-
- fn font(mut self, family_name: impl Into<Arc<str>>) -> Self {
- self.declared_style().font_family = Some(family_name.into());
- self
- }
-}
@@ -1,26 +0,0 @@
-use crate::{
- adapter::AdapterElement,
- element::{AnyElement, Element},
-};
-use gpui::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> {
- use gpui::Element as _;
- AdapterElement((self.0)(cx)).into_any()
- }
-}
@@ -1,79 +0,0 @@
-use std::{any::TypeId, rc::Rc};
-
-use crate::{element::LayoutId, style::Style};
-use anyhow::{anyhow, Result};
-use derive_more::{Deref, DerefMut};
-use gpui::{geometry::Size, scene::EventHandler, EventContext, Layout, MeasureParams};
-pub use gpui::{taffy::tree::NodeId, ViewContext as LegacyViewContext};
-
-#[derive(Deref, DerefMut)]
-pub struct ViewContext<'a, 'b, 'c, V> {
- #[deref]
- #[deref_mut]
- pub(crate) legacy_cx: &'c mut LegacyViewContext<'a, 'b, V>,
-}
-
-impl<'a, 'b, 'c, V: 'static> ViewContext<'a, 'b, 'c, V> {
- pub fn new(legacy_cx: &'c mut LegacyViewContext<'a, 'b, V>) -> Self {
- Self { legacy_cx }
- }
-
- pub fn add_layout_node(
- &mut self,
- style: Style,
- children: impl IntoIterator<Item = NodeId>,
- ) -> Result<LayoutId> {
- let rem_size = self.rem_size();
- let style = style.to_taffy(rem_size);
- let id = self
- .legacy_cx
- .layout_engine()
- .ok_or_else(|| anyhow!("no layout engine"))?
- .add_node(style, children)?;
-
- Ok(id)
- }
-
- pub fn add_measured_layout_node<F>(&mut self, style: Style, measure: F) -> Result<LayoutId>
- where
- F: Fn(MeasureParams) -> Size<f32> + Sync + Send + 'static,
- {
- let rem_size = self.rem_size();
- let layout_id = self
- .layout_engine()
- .ok_or_else(|| anyhow!("no layout engine"))?
- .add_measured_node(style.to_taffy(rem_size), measure)?;
-
- Ok(layout_id)
- }
-
- pub fn on_event<E: 'static>(
- &mut self,
- order: u32,
- handler: impl Fn(&mut V, &E, &mut EventContext<V>) + 'static,
- ) {
- let view = self.weak_handle();
-
- self.scene().event_handlers.push(EventHandler {
- order,
- handler: Rc::new(move |event, window_cx| {
- if let Some(view) = view.upgrade(window_cx) {
- view.update(window_cx, |view, view_cx| {
- let mut event_cx = EventContext::new(view_cx);
- handler(view, event.downcast_ref().unwrap(), &mut event_cx);
- event_cx.bubble
- })
- } else {
- true
- }
- }),
- event_type: TypeId::of::<E>(),
- })
- }
-
- pub(crate) fn computed_layout(&mut self, layout_id: LayoutId) -> Result<Layout> {
- self.layout_engine()
- .ok_or_else(|| anyhow!("no layout engine present"))?
- .computed_layout(layout_id)
- }
-}
@@ -1,60 +0,0 @@
-use crate::{style::Style, Element, IntoElement, ViewContext};
-use gpui::{
- geometry::{Point, Size},
- taffy::style::Overflow,
- AnyElement, View, ViewHandle,
-};
-
-impl<ParentView: 'static, ChildView: View> Element<ParentView> for ViewHandle<ChildView> {
- type PaintState = AnyElement<ChildView>;
-
- fn layout(
- &mut self,
- _: &mut ParentView,
- cx: &mut ViewContext<ParentView>,
- ) -> anyhow::Result<(gpui::LayoutId, Self::PaintState)>
- where
- Self: Sized,
- {
- let layout_id = cx.add_layout_node(
- Style {
- overflow: Point {
- x: Overflow::Hidden,
- y: Overflow::Hidden,
- },
- size: Size::full(),
- ..Default::default()
- },
- None,
- )?;
- let element = self.update(cx, |view, cx| view.render(cx));
- Ok((layout_id, element))
- }
-
- fn paint(
- &mut self,
- _: &mut ParentView,
- parent_origin: gpui::geometry::vector::Vector2F,
- layout: &gpui::Layout,
- element: &mut AnyElement<ChildView>,
- cx: &mut ViewContext<ParentView>,
- ) where
- Self: Sized,
- {
- self.update(cx, |view, cx| {
- let bounds = layout.bounds + parent_origin;
- element.layout(gpui::SizeConstraint::strict(bounds.size()), view, cx);
- cx.paint_layer(Some(layout.bounds), |cx| {
- element.paint(bounds.origin(), bounds, view, cx);
- });
- })
- }
-}
-
-impl<ParentView: 'static, ChildView: View> IntoElement<ParentView> for ViewHandle<ChildView> {
- type Element = Self;
-
- fn into_element(self) -> Self::Element {
- self
- }
-}
@@ -1,14 +0,0 @@
-[package]
-name = "gpui2_macros"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/gpui2_macros.rs"
-proc-macro = true
-
-[dependencies]
-syn = "1.0.72"
-quote = "1.0.9"
-proc-macro2 = "1.0.66"
@@ -1,93 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::Ident;
-use quote::quote;
-use syn::{parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics};
-
-use crate::derive_into_element::impl_into_element;
-
-pub fn derive_element(input: TokenStream) -> TokenStream {
- let ast = parse_macro_input!(input as DeriveInput);
- let type_name = ast.ident;
- let placeholder_view_generics: Generics = parse_quote! { <V: 'static> };
-
- let (impl_generics, type_generics, where_clause, view_type_name, lifetimes) =
- if let Some(first_type_param) = ast.generics.params.iter().find_map(|param| {
- if let GenericParam::Type(type_param) = param {
- Some(type_param.ident.clone())
- } else {
- None
- }
- }) {
- let mut lifetimes = vec![];
- for param in ast.generics.params.iter() {
- if let GenericParam::Lifetime(lifetime_def) = param {
- lifetimes.push(lifetime_def.lifetime.clone());
- }
- }
- let generics = ast.generics.split_for_impl();
- (
- generics.0,
- Some(generics.1),
- generics.2,
- first_type_param,
- lifetimes,
- )
- } else {
- let generics = placeholder_view_generics.split_for_impl();
- let placeholder_view_type_name: Ident = parse_quote! { V };
- (
- generics.0,
- None,
- generics.2,
- placeholder_view_type_name,
- vec![],
- )
- };
-
- let lifetimes = if !lifetimes.is_empty() {
- quote! { <#(#lifetimes),*> }
- } else {
- quote! {}
- };
-
- let impl_into_element = impl_into_element(
- &impl_generics,
- &view_type_name,
- &type_name,
- &type_generics,
- &where_clause,
- );
-
- let gen = quote! {
- impl #impl_generics gpui2::element::Element<#view_type_name> for #type_name #type_generics
- #where_clause
- {
- type PaintState = gpui2::element::AnyElement<#view_type_name #lifetimes>;
-
- fn layout(
- &mut self,
- view: &mut V,
- cx: &mut gpui2::ViewContext<V>,
- ) -> anyhow::Result<(gpui2::element::LayoutId, Self::PaintState)> {
- let mut rendered_element = self.render(view, cx).into_element().into_any();
- let layout_id = rendered_element.layout(view, cx)?;
- Ok((layout_id, rendered_element))
- }
-
- fn paint(
- &mut self,
- view: &mut V,
- parent_origin: gpui2::Vector2F,
- _: &gpui2::element::Layout,
- rendered_element: &mut Self::PaintState,
- cx: &mut gpui2::ViewContext<V>,
- ) {
- rendered_element.paint(view, parent_origin, cx);
- }
- }
-
- #impl_into_element
- };
-
- gen.into()
-}
@@ -1,69 +0,0 @@
-use proc_macro::TokenStream;
-use quote::quote;
-use syn::{
- parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics, Ident, WhereClause,
-};
-
-pub fn derive_into_element(input: TokenStream) -> TokenStream {
- let ast = parse_macro_input!(input as DeriveInput);
- let type_name = ast.ident;
-
- let placeholder_view_generics: Generics = parse_quote! { <V: 'static> };
- let placeholder_view_type_name: Ident = parse_quote! { V };
- let view_type_name: Ident;
- let impl_generics: syn::ImplGenerics<'_>;
- let type_generics: Option<syn::TypeGenerics<'_>>;
- let where_clause: Option<&'_ WhereClause>;
-
- match ast.generics.params.iter().find_map(|param| {
- if let GenericParam::Type(type_param) = param {
- Some(type_param.ident.clone())
- } else {
- None
- }
- }) {
- Some(type_name) => {
- view_type_name = type_name;
- let generics = ast.generics.split_for_impl();
- impl_generics = generics.0;
- type_generics = Some(generics.1);
- where_clause = generics.2;
- }
- _ => {
- view_type_name = placeholder_view_type_name;
- let generics = placeholder_view_generics.split_for_impl();
- impl_generics = generics.0;
- type_generics = None;
- where_clause = generics.2;
- }
- }
-
- impl_into_element(
- &impl_generics,
- &view_type_name,
- &type_name,
- &type_generics,
- &where_clause,
- )
- .into()
-}
-
-pub fn impl_into_element(
- impl_generics: &syn::ImplGenerics<'_>,
- view_type_name: &Ident,
- type_name: &Ident,
- type_generics: &Option<syn::TypeGenerics<'_>>,
- where_clause: &Option<&WhereClause>,
-) -> proc_macro2::TokenStream {
- quote! {
- impl #impl_generics gpui2::element::IntoElement<#view_type_name> for #type_name #type_generics
- #where_clause
- {
- type Element = Self;
-
- fn into_element(self) -> Self {
- self
- }
- }
- }
-}
@@ -1,20 +0,0 @@
-use proc_macro::TokenStream;
-
-mod derive_element;
-mod derive_into_element;
-mod styleable_helpers;
-
-#[proc_macro]
-pub fn styleable_helpers(args: TokenStream) -> TokenStream {
- styleable_helpers::styleable_helpers(args)
-}
-
-#[proc_macro_derive(Element, attributes(element_crate))]
-pub fn derive_element(input: TokenStream) -> TokenStream {
- derive_element::derive_element(input)
-}
-
-#[proc_macro_derive(IntoElement, attributes(element_crate))]
-pub fn derive_into_element(input: TokenStream) -> TokenStream {
- derive_into_element::derive_into_element(input)
-}
@@ -1,408 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::{format_ident, quote};
-use syn::{
- parse::{Parse, ParseStream, Result},
- parse_macro_input,
-};
-
-struct StyleableMacroInput;
-
-impl Parse for StyleableMacroInput {
- fn parse(_input: ParseStream) -> Result<Self> {
- Ok(StyleableMacroInput)
- }
-}
-
-pub fn styleable_helpers(input: TokenStream) -> TokenStream {
- let _ = parse_macro_input!(input as StyleableMacroInput);
- let methods = generate_methods();
- let output = quote! {
- #(#methods)*
- };
-
- output.into()
-}
-
-fn generate_methods() -> Vec<TokenStream2> {
- let mut methods = Vec::new();
-
- for (prefix, auto_allowed, fields) in box_prefixes() {
- methods.push(generate_custom_value_setter(
- prefix,
- if auto_allowed {
- quote! { Length }
- } else {
- quote! { DefiniteLength }
- },
- &fields,
- ));
-
- for (suffix, length_tokens, doc_string) in box_suffixes() {
- if suffix != "auto" || auto_allowed {
- methods.push(generate_predefined_setter(
- prefix,
- suffix,
- &fields,
- &length_tokens,
- false,
- doc_string,
- ));
- }
-
- if suffix != "auto" {
- methods.push(generate_predefined_setter(
- prefix,
- suffix,
- &fields,
- &length_tokens,
- true,
- doc_string,
- ));
- }
- }
- }
-
- for (prefix, fields) in corner_prefixes() {
- methods.push(generate_custom_value_setter(
- prefix,
- quote! { AbsoluteLength },
- &fields,
- ));
-
- for (suffix, radius_tokens, doc_string) in corner_suffixes() {
- methods.push(generate_predefined_setter(
- prefix,
- suffix,
- &fields,
- &radius_tokens,
- false,
- doc_string,
- ));
- }
- }
-
- for (prefix, fields) in border_prefixes() {
- for (suffix, width_tokens, doc_string) in border_suffixes() {
- methods.push(generate_predefined_setter(
- prefix,
- suffix,
- &fields,
- &width_tokens,
- false,
- doc_string,
- ));
- }
- }
- methods
-}
-
-fn generate_predefined_setter(
- name: &'static str,
- length: &'static str,
- fields: &Vec<TokenStream2>,
- length_tokens: &TokenStream2,
- negate: bool,
- doc_string: &'static str,
-) -> TokenStream2 {
- let (negation_prefix, negation_token) = if negate {
- ("neg_", quote! { - })
- } else {
- ("", quote! {})
- };
-
- let method_name = if length.is_empty() {
- format_ident!("{}{}", negation_prefix, name)
- } else {
- format_ident!("{}{}_{}", negation_prefix, name, length)
- };
-
- let field_assignments = fields
- .iter()
- .map(|field_tokens| {
- quote! {
- style.#field_tokens = Some((#negation_token gpui2::geometry::#length_tokens).into());
- }
- })
- .collect::<Vec<_>>();
-
- let method = quote! {
- #[doc = #doc_string]
- fn #method_name(mut self) -> Self where Self: std::marker::Sized {
- let mut style = self.declared_style();
- #(#field_assignments)*
- self
- }
- };
-
- method
-}
-
-fn generate_custom_value_setter(
- prefix: &'static str,
- length_type: TokenStream2,
- fields: &Vec<TokenStream2>,
-) -> TokenStream2 {
- let method_name = format_ident!("{}", prefix);
-
- let mut iter = fields.into_iter();
- let last = iter.next_back().unwrap();
- let field_assignments = iter
- .map(|field_tokens| {
- quote! {
- style.#field_tokens = Some(length.clone().into());
- }
- })
- .chain(std::iter::once(quote! {
- style.#last = Some(length.into());
- }))
- .collect::<Vec<_>>();
-
- let method = quote! {
- fn #method_name(mut self, length: impl std::clone::Clone + Into<gpui2::geometry::#length_type>) -> Self where Self: std::marker::Sized {
- let mut style = self.declared_style();
- #(#field_assignments)*
- self
- }
- };
-
- method
-}
-
-fn box_prefixes() -> Vec<(&'static str, bool, Vec<TokenStream2>)> {
- vec![
- ("w", true, vec![quote! { size.width }]),
- ("h", true, vec![quote! { size.height }]),
- (
- "size",
- true,
- vec![quote! {size.width}, quote! {size.height}],
- ),
- ("min_w", true, vec![quote! { min_size.width }]),
- ("min_h", true, vec![quote! { min_size.height }]),
- ("max_w", true, vec![quote! { max_size.width }]),
- ("max_h", true, vec![quote! { max_size.height }]),
- (
- "m",
- true,
- vec![
- quote! { margin.top },
- quote! { margin.bottom },
- quote! { margin.left },
- quote! { margin.right },
- ],
- ),
- ("mt", true, vec![quote! { margin.top }]),
- ("mb", true, vec![quote! { margin.bottom }]),
- (
- "my",
- true,
- vec![quote! { margin.top }, quote! { margin.bottom }],
- ),
- (
- "mx",
- true,
- vec![quote! { margin.left }, quote! { margin.right }],
- ),
- ("ml", true, vec![quote! { margin.left }]),
- ("mr", true, vec![quote! { margin.right }]),
- (
- "p",
- false,
- vec![
- quote! { padding.top },
- quote! { padding.bottom },
- quote! { padding.left },
- quote! { padding.right },
- ],
- ),
- ("pt", false, vec![quote! { padding.top }]),
- ("pb", false, vec![quote! { padding.bottom }]),
- (
- "px",
- false,
- vec![quote! { padding.left }, quote! { padding.right }],
- ),
- (
- "py",
- false,
- vec![quote! { padding.top }, quote! { padding.bottom }],
- ),
- ("pl", false, vec![quote! { padding.left }]),
- ("pr", false, vec![quote! { padding.right }]),
- ("top", true, vec![quote! { inset.top }]),
- ("bottom", true, vec![quote! { inset.bottom }]),
- ("left", true, vec![quote! { inset.left }]),
- ("right", true, vec![quote! { inset.right }]),
- (
- "gap",
- false,
- vec![quote! { gap.width }, quote! { gap.height }],
- ),
- ("gap_x", false, vec![quote! { gap.width }]),
- ("gap_y", false, vec![quote! { gap.height }]),
- ]
-}
-
-fn box_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
- vec![
- ("0", quote! { pixels(0.) }, "0px"),
- ("0p5", quote! { rems(0.125) }, "2px (0.125rem)"),
- ("1", quote! { rems(0.25) }, "4px (0.25rem)"),
- ("1p5", quote! { rems(0.375) }, "6px (0.375rem)"),
- ("2", quote! { rems(0.5) }, "8px (0.5rem)"),
- ("2p5", quote! { rems(0.625) }, "10px (0.625rem)"),
- ("3", quote! { rems(0.75) }, "12px (0.75rem)"),
- ("3p5", quote! { rems(0.875) }, "14px (0.875rem)"),
- ("4", quote! { rems(1.) }, "16px (1rem)"),
- ("5", quote! { rems(1.25) }, "20px (1.25rem)"),
- ("6", quote! { rems(1.5) }, "24px (1.5rem)"),
- ("7", quote! { rems(1.75) }, "28px (1.75rem)"),
- ("8", quote! { rems(2.0) }, "32px (2rem)"),
- ("9", quote! { rems(2.25) }, "36px (2.25rem)"),
- ("10", quote! { rems(2.5) }, "40px (2.5rem)"),
- ("11", quote! { rems(2.75) }, "44px (2.75rem)"),
- ("12", quote! { rems(3.) }, "48px (3rem)"),
- ("16", quote! { rems(4.) }, "64px (4rem)"),
- ("20", quote! { rems(5.) }, "80px (5rem)"),
- ("24", quote! { rems(6.) }, "96px (6rem)"),
- ("32", quote! { rems(8.) }, "128px (8rem)"),
- ("40", quote! { rems(10.) }, "160px (10rem)"),
- ("48", quote! { rems(12.) }, "192px (12rem)"),
- ("56", quote! { rems(14.) }, "224px (14rem)"),
- ("64", quote! { rems(16.) }, "256px (16rem)"),
- ("72", quote! { rems(18.) }, "288px (18rem)"),
- ("80", quote! { rems(20.) }, "320px (20rem)"),
- ("96", quote! { rems(24.) }, "384px (24rem)"),
- ("auto", quote! { auto() }, "Auto"),
- ("px", quote! { pixels(1.) }, "1px"),
- ("full", quote! { relative(1.) }, "100%"),
- ("1_2", quote! { relative(0.5) }, "50% (1/2)"),
- ("1_3", quote! { relative(1./3.) }, "33% (1/3)"),
- ("2_3", quote! { relative(2./3.) }, "66% (2/3)"),
- ("1_4", quote! { relative(0.25) }, "25% (1/4)"),
- ("2_4", quote! { relative(0.5) }, "50% (2/4)"),
- ("3_4", quote! { relative(0.75) }, "75% (3/4)"),
- ("1_5", quote! { relative(0.2) }, "20% (1/5)"),
- ("2_5", quote! { relative(0.4) }, "40% (2/5)"),
- ("3_5", quote! { relative(0.6) }, "60% (3/5)"),
- ("4_5", quote! { relative(0.8) }, "80% (4/5)"),
- ("1_6", quote! { relative(1./6.) }, "16% (1/6)"),
- ("5_6", quote! { relative(5./6.) }, "80% (5/6)"),
- ("1_12", quote! { relative(1./12.) }, "8% (1/12)"),
- ]
-}
-
-fn corner_prefixes() -> Vec<(&'static str, Vec<TokenStream2>)> {
- vec![
- (
- "rounded",
- vec![
- quote! { corner_radii.top_left },
- quote! { corner_radii.top_right },
- quote! { corner_radii.bottom_right },
- quote! { corner_radii.bottom_left },
- ],
- ),
- (
- "rounded_t",
- vec![
- quote! { corner_radii.top_left },
- quote! { corner_radii.top_right },
- ],
- ),
- (
- "rounded_b",
- vec![
- quote! { corner_radii.bottom_left },
- quote! { corner_radii.bottom_right },
- ],
- ),
- (
- "rounded_r",
- vec![
- quote! { corner_radii.top_right },
- quote! { corner_radii.bottom_right },
- ],
- ),
- (
- "rounded_l",
- vec![
- quote! { corner_radii.top_left },
- quote! { corner_radii.bottom_left },
- ],
- ),
- ("rounded_tl", vec![quote! { corner_radii.top_left }]),
- ("rounded_tr", vec![quote! { corner_radii.top_right }]),
- ("rounded_bl", vec![quote! { corner_radii.bottom_left }]),
- ("rounded_br", vec![quote! { corner_radii.bottom_right }]),
- ]
-}
-
-fn corner_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
- vec![
- ("none", quote! { pixels(0.) }, "0px"),
- ("sm", quote! { rems(0.125) }, "2px (0.125rem)"),
- ("md", quote! { rems(0.25) }, "4px (0.25rem)"),
- ("lg", quote! { rems(0.5) }, "8px (0.5rem)"),
- ("xl", quote! { rems(0.75) }, "12px (0.75rem)"),
- ("2xl", quote! { rems(1.) }, "16px (1rem)"),
- ("3xl", quote! { rems(1.5) }, "24px (1.5rem)"),
- ("full", quote! { pixels(9999.) }, "9999px"),
- ]
-}
-
-fn border_prefixes() -> Vec<(&'static str, Vec<TokenStream2>)> {
- vec![
- (
- "border",
- vec![
- quote! { border_widths.top },
- quote! { border_widths.right },
- quote! { border_widths.bottom },
- quote! { border_widths.left },
- ],
- ),
- ("border_t", vec![quote! { border_widths.top }]),
- ("border_b", vec![quote! { border_widths.bottom }]),
- ("border_r", vec![quote! { border_widths.right }]),
- ("border_l", vec![quote! { border_widths.left }]),
- (
- "border_x",
- vec![
- quote! { border_widths.left },
- quote! { border_widths.right },
- ],
- ),
- (
- "border_y",
- vec![
- quote! { border_widths.top },
- quote! { border_widths.bottom },
- ],
- ),
- ]
-}
-
-fn border_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
- vec![
- ("", quote! { pixels(1.)}, "1px"),
- ("0", quote! { pixels(0.)}, "0px"),
- ("1", quote! { pixels(1.) }, "1px"),
- ("2", quote! { pixels(2.) }, "2px"),
- ("3", quote! { pixels(3.) }, "3px"),
- ("4", quote! { pixels(4.) }, "4px"),
- ("5", quote! { pixels(5.) }, "5px"),
- ("6", quote! { pixels(6.) }, "6px"),
- ("7", quote! { pixels(7.) }, "7px"),
- ("8", quote! { pixels(8.) }, "8px"),
- ("9", quote! { pixels(9.) }, "9px"),
- ("10", quote! { pixels(10.) }, "10px"),
- ("11", quote! { pixels(11.) }, "11px"),
- ("12", quote! { pixels(12.) }, "12px"),
- ("16", quote! { pixels(16.) }, "16px"),
- ("20", quote! { pixels(20.) }, "20px"),
- ("24", quote! { pixels(24.) }, "24px"),
- ("32", quote! { pixels(32.) }, "32px"),
- ]
-}