Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'gpui2-element-renderer' into zed2

Browse source
This commit is contained in:
Marshall Bowers 2023-10-26 15:23:02 +02:00
commit d62c51a4b8
66 changed files with 897 additions and 1346 deletions
Download patch file Download diff file Expand all files Collapse all files

34
crates/ui2/src/components/assistant_panel.rs
View file

@ -1,22 +1,18 @@
use std::marker::PhantomData;
use gpui2::{rems, AbsoluteLength};
use crate::prelude::*;
use crate::{Icon, IconButton, Label, Panel, PanelSide};
#[derive(Element)]
pub struct AssistantPanel<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct AssistantPanel {
id: ElementId,
state_type: PhantomData<S>,
current_side: PanelSide,
}
impl<S: 'static + Send + Sync> AssistantPanel<S> {
impl AssistantPanel {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
current_side: PanelSide::default(),
}
}
@ -26,7 +22,7 @@ impl<S: 'static + Send + Sync> AssistantPanel<S> {
self
}
fn render(&mut self, view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
Panel::new(self.id.clone(), cx)
.children(vec![div()
.flex()
@ -69,7 +65,7 @@ impl<S: 'static + Send + Sync> AssistantPanel<S> {
.overflow_y_scroll()
.child(Label::new("Is this thing on?")),
)
.into_any()])
.render()])
.side(self.current_side)
.width(AbsoluteLength::Rems(rems(32.)))
}
@ -84,25 +80,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct AssistantPanelStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct AssistantPanelStory {}
impl<S: 'static + Send + Sync> AssistantPanelStory<S> {
impl AssistantPanelStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self {}
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
Story::container(cx)
.child(Story::title_for::<_, AssistantPanel<S>>(cx))
.child(Story::title_for::<_, AssistantPanel>(cx))
.child(Story::label(cx, "Default"))
.child(AssistantPanel::new("assistant-panel"))
}

38
crates/ui2/src/components/breadcrumb.rs
View file

@ -1,41 +1,33 @@
use std::marker::PhantomData;
use std::path::PathBuf;
use gpui2::Div;
use crate::prelude::*;
use crate::{h_stack, HighlightedText};
#[derive(Clone)]
pub struct Symbol(pub Vec<HighlightedText>);
#[derive(Element)]
pub struct Breadcrumb<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct Breadcrumb {
path: PathBuf,
symbols: Vec<Symbol>,
}
impl<S: 'static + Send + Sync> Breadcrumb<S> {
impl Breadcrumb {
pub fn new(path: PathBuf, symbols: Vec<Symbol>) -> Self {
Self {
state_type: PhantomData,
path,
symbols,
}
}
fn render_separator(&self, cx: &WindowContext) -> Div<S> {
fn render_separator<V: 'static>(&self, cx: &WindowContext) -> Div<V> {
let theme = theme(cx);
div().child(" › ").text_color(theme.text_muted)
}
fn render(
&mut self,
view_state: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, view_state: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let theme = theme(cx);
let symbols_len = self.symbols.len();
@ -90,27 +82,19 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct BreadcrumbStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct BreadcrumbStory;
impl<S: 'static + Send + Sync> BreadcrumbStory<S> {
impl BreadcrumbStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
view_state: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, view_state: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let theme = theme(cx);
Story::container(cx)
.child(Story::title_for::<_, Breadcrumb<S>>(cx))
.child(Story::title_for::<_, Breadcrumb>(cx))
.child(Story::label(cx, "Default"))
.child(Breadcrumb::new(
PathBuf::from_str("crates/ui/src/components/toolbar.rs").unwrap(),

36
crates/ui2/src/components/buffer.rs
View file

@ -1,5 +1,3 @@
use std::marker::PhantomData;
use gpui2::{Hsla, WindowContext};
use crate::prelude::*;
@ -109,10 +107,9 @@ impl BufferRow {
}
}
#[derive(Element, Clone)]
pub struct Buffer<S: 'static + Send + Sync + Clone> {
#[derive(Component, Clone)]
pub struct Buffer {
id: ElementId,
state_type: PhantomData<S>,
rows: Option<BufferRows>,
readonly: bool,
language: Option<String>,
@ -120,11 +117,10 @@ pub struct Buffer<S: 'static + Send + Sync + Clone> {
path: Option<String>,
}
impl<S: 'static + Send + Sync + Clone> Buffer<S> {
impl Buffer {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
rows: Some(BufferRows::default()),
readonly: false,
language: None,
@ -158,7 +154,7 @@ impl<S: 'static + Send + Sync + Clone> Buffer<S> {
self
}
fn render_row(row: BufferRow, cx: &WindowContext) -> impl Element<ViewState = S> {
fn render_row<S: 'static>(row: BufferRow, cx: &WindowContext) -> impl Component<S> {
let theme = theme(cx);
let line_background = if row.current {
@ -208,7 +204,7 @@ impl<S: 'static + Send + Sync + Clone> Buffer<S> {
}))
}
fn render_rows(&self, cx: &WindowContext) -> Vec<impl Element<ViewState = S>> {
fn render_rows<S: 'static>(&self, cx: &WindowContext) -> Vec<impl Component<S>> {
match &self.rows {
Some(rows) => rows
.rows
@ -219,7 +215,7 @@ impl<S: 'static + Send + Sync + Clone> Buffer<S> {
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let rows = self.render_rows(cx);
@ -246,27 +242,19 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct BufferStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct BufferStory;
impl<S: 'static + Send + Sync + Clone> BufferStory<S> {
impl BufferStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
Story::container(cx)
.child(Story::title_for::<_, Buffer<S>>(cx))
.child(Story::title_for::<_, Buffer>(cx))
.child(Story::label(cx, "Default"))
.child(div().w(rems(64.)).h_96().child(empty_buffer_example()))
.child(Story::label(cx, "Hello World (Rust)"))

2
crates/ui2/src/components/buffer_search.rs
View file

@ -25,7 +25,7 @@ impl BufferSearch {
view(cx.entity(|cx| Self::new()), Self::render)
}
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element<ViewState = Self> {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Component<Self> {
let theme = theme(cx);
h_stack().bg(theme.toolbar).p_2().child(

44
crates/ui2/src/components/chat_panel.rs
View file

@ -1,17 +1,15 @@
use std::marker::PhantomData;
use chrono::NaiveDateTime;
use crate::prelude::*;
use crate::{Icon, IconButton, Input, Label, LabelColor};
#[derive(Element)]
pub struct ChatPanel<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct ChatPanel {
element_id: ElementId,
messages: Vec<ChatMessage<S>>,
messages: Vec<ChatMessage>,
}
impl<S: 'static + Send + Sync> ChatPanel<S> {
impl ChatPanel {
pub fn new(element_id: impl Into<ElementId>) -> Self {
Self {
element_id: element_id.into(),
@ -19,12 +17,12 @@ impl<S: 'static + Send + Sync> ChatPanel<S> {
}
}
pub fn messages(mut self, messages: Vec<ChatMessage<S>>) -> Self {
pub fn messages(mut self, messages: Vec<ChatMessage>) -> Self {
self.messages = messages;
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div()
.id(self.element_id.clone())
.flex()
@ -70,25 +68,23 @@ impl<S: 'static + Send + Sync> ChatPanel<S> {
}
}
#[derive(Element)]
pub struct ChatMessage<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct ChatMessage {
author: String,
text: String,
sent_at: NaiveDateTime,
}
impl<S: 'static + Send + Sync> ChatMessage<S> {
impl ChatMessage {
pub fn new(author: String, text: String, sent_at: NaiveDateTime) -> Self {
Self {
state_type: PhantomData,
author,
text,
sent_at,
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div()
.flex()
.flex_col()
@ -117,25 +113,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct ChatPanelStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct ChatPanelStory;
impl<S: 'static + Send + Sync> ChatPanelStory<S> {
impl ChatPanelStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, ChatPanel<S>>(cx))
.child(Story::title_for::<_, ChatPanel>(cx))
.child(Story::label(cx, "Default"))
.child(
Panel::new("chat-panel-1-outer", cx)

35
crates/ui2/src/components/collab_panel.rs
View file

@ -3,23 +3,18 @@ use crate::{
static_collab_panel_channels, static_collab_panel_current_call, v_stack, Icon, List,
ListHeader, ToggleState,
};
use std::marker::PhantomData;
#[derive(Element)]
pub struct CollabPanel<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct CollabPanel {
id: ElementId,
state_type: PhantomData<S>,
}
impl<S: 'static + Send + Sync> CollabPanel<S> {
impl CollabPanel {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
}
Self { id: id.into() }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
v_stack()
@ -98,25 +93,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct CollabPanelStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct CollabPanelStory;
impl<S: 'static + Send + Sync> CollabPanelStory<S> {
impl CollabPanelStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, CollabPanel<S>>(cx))
.child(Story::title_for::<_, CollabPanel>(cx))
.child(Story::label(cx, "Default"))
.child(CollabPanel::new("collab-panel"))
}

36
crates/ui2/src/components/command_palette.rs
View file

@ -1,23 +1,17 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{example_editor_actions, OrderMethod, Palette};
#[derive(Element)]
pub struct CommandPalette<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct CommandPalette {
id: ElementId,
state_type: PhantomData<S>,
}
impl<S: 'static + Send + Sync> CommandPalette<S> {
impl CommandPalette {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
}
Self { id: id.into() }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div().id(self.id.clone()).child(
Palette::new("palette")
.items(example_editor_actions())
@ -37,25 +31,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct CommandPaletteStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct CommandPaletteStory;
impl<S: 'static + Send + Sync> CommandPaletteStory<S> {
impl CommandPaletteStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, CommandPalette<S>>(cx))
.child(Story::title_for::<_, CommandPalette>(cx))
.child(Story::label(cx, "Default"))
.child(CommandPalette::new("command-palette"))
}

44
crates/ui2/src/components/context_menu.rs
View file

@ -1,14 +1,14 @@
use crate::{prelude::*, ListItemVariant};
use crate::{v_stack, Label, List, ListEntry, ListItem, ListSeparator, ListSubHeader};
pub enum ContextMenuItem<S: 'static + Send + Sync> {
pub enum ContextMenuItem {
Header(SharedString),
Entry(Label<S>),
Entry(Label),
Separator,
}
impl<S: 'static + Send + Sync> ContextMenuItem<S> {
fn to_list_item(self) -> ListItem<S> {
impl ContextMenuItem {
fn to_list_item<V: 'static>(self) -> ListItem<V> {
match self {
ContextMenuItem::Header(label) => ListSubHeader::new(label).into(),
ContextMenuItem::Entry(label) => {
@ -26,23 +26,23 @@ impl<S: 'static + Send + Sync> ContextMenuItem<S> {
Self::Separator
}
pub fn entry(label: Label<S>) -> Self {
pub fn entry(label: Label) -> Self {
Self::Entry(label)
}
}
#[derive(Element)]
pub struct ContextMenu<S: 'static + Send + Sync> {
items: Vec<ContextMenuItem<S>>,
#[derive(Component)]
pub struct ContextMenu {
items: Vec<ContextMenuItem>,
}
impl<S: 'static + Send + Sync> ContextMenu<S> {
pub fn new(items: impl IntoIterator<Item = ContextMenuItem<S>>) -> Self {
impl ContextMenu {
pub fn new(items: impl IntoIterator<Item = ContextMenuItem>) -> Self {
Self {
items: items.into_iter().collect(),
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
v_stack()
@ -67,31 +67,21 @@ pub use stories::*;
#[cfg(feature = "stories")]
mod stories {
use std::marker::PhantomData;
use crate::story::Story;
use super::*;
#[derive(Element)]
pub struct ContextMenuStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct ContextMenuStory;
impl<S: 'static + Send + Sync> ContextMenuStory<S> {
impl ContextMenuStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, ContextMenu<S>>(cx))
.child(Story::title_for::<_, ContextMenu>(cx))
.child(Story::label(cx, "Default"))
.child(ContextMenu::new([
ContextMenuItem::header("Section header"),

36
crates/ui2/src/components/copilot.rs
View file

@ -1,22 +1,16 @@
use std::marker::PhantomData;
use crate::{prelude::*, Button, Label, LabelColor, Modal};
#[derive(Element)]
pub struct CopilotModal<S: 'static + Send + Sync + Clone> {
#[derive(Component)]
pub struct CopilotModal {
id: ElementId,
state_type: PhantomData<S>,
}
impl<S: 'static + Send + Sync + Clone> CopilotModal<S> {
impl CopilotModal {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
}
Self { id: id.into() }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div().id(self.id.clone()).child(
Modal::new("some-id")
.title("Connect Copilot to Zed")
@ -35,25 +29,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct CopilotModalStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct CopilotModalStory;
impl<S: 'static + Send + Sync + Clone> CopilotModalStory<S> {
impl CopilotModalStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, CopilotModal<S>>(cx))
.child(Story::title_for::<_, CopilotModal>(cx))
.child(Story::label(cx, "Default"))
.child(CopilotModal::new("copilot-modal"))
}

10
crates/ui2/src/components/editor_pane.rs
View file

@ -10,10 +10,10 @@ use crate::{
#[derive(Clone)]
pub struct EditorPane {
tabs: Vec<Tab<Self>>,
tabs: Vec<Tab>,
path: PathBuf,
symbols: Vec<Symbol>,
buffer: Buffer<Self>,
buffer: Buffer,
buffer_search: View<BufferSearch>,
is_buffer_search_open: bool,
}
@ -21,10 +21,10 @@ pub struct EditorPane {
impl EditorPane {
pub fn new(
cx: &mut WindowContext,
tabs: Vec<Tab<Self>>,
tabs: Vec<Tab>,
path: PathBuf,
symbols: Vec<Symbol>,
buffer: Buffer<Self>,
buffer: Buffer,
) -> Self {
Self {
tabs,
@ -49,7 +49,7 @@ impl EditorPane {
)
}
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element<ViewState = Self> {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Component<Self> {
v_stack()
.w_full()
.h_full()

32
crates/ui2/src/components/facepile.rs
View file

@ -1,23 +1,19 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{Avatar, Player};
#[derive(Element)]
pub struct Facepile<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct Facepile {
players: Vec<Player>,
}
impl<S: 'static + Send + Sync> Facepile<S> {
impl Facepile {
pub fn new<P: Iterator<Item = Player>>(players: P) -> Self {
Self {
state_type: PhantomData,
players: players.collect(),
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let player_count = self.players.len();
let player_list = self.players.iter().enumerate().map(|(ix, player)| {
let isnt_last = ix < player_count - 1;
@ -39,27 +35,19 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct FacepileStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct FacepileStory;
impl<S: 'static + Send + Sync> FacepileStory<S> {
impl FacepileStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let players = static_players();
Story::container(cx)
.child(Story::title_for::<_, Facepile<S>>(cx))
.child(Story::title_for::<_, Facepile>(cx))
.child(Story::label(cx, "Default"))
.child(
div()

20
crates/ui2/src/components/icon_button.rs
View file

@ -1,4 +1,3 @@
use std::marker::PhantomData;
use std::sync::Arc;
use gpui2::MouseButton;
@ -6,19 +5,18 @@ use gpui2::MouseButton;
use crate::{h_stack, prelude::*};
use crate::{ClickHandler, Icon, IconColor, IconElement};
struct IconButtonHandlers<S: 'static + Send + Sync> {
struct IconButtonHandlers<S: 'static> {
click: Option<ClickHandler<S>>,
}
impl<S: 'static + Send + Sync> Default for IconButtonHandlers<S> {
impl<S: 'static> Default for IconButtonHandlers<S> {
fn default() -> Self {
Self { click: None }
}
}
#[derive(Element)]
pub struct IconButton<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct IconButton<S: 'static> {
id: ElementId,
icon: Icon,
color: IconColor,
@ -27,10 +25,9 @@ pub struct IconButton<S: 'static + Send + Sync> {
handlers: IconButtonHandlers<S>,
}
impl<S: 'static + Send + Sync> IconButton<S> {
impl<S: 'static> IconButton<S> {
pub fn new(id: impl Into<ElementId>, icon: Icon) -> Self {
Self {
state_type: PhantomData,
id: id.into(),
icon,
color: IconColor::default(),
@ -60,15 +57,12 @@ impl<S: 'static + Send + Sync> IconButton<S> {
self
}
pub fn on_click(
mut self,
handler: impl Fn(&mut S, &mut ViewContext<S>) + 'static + Send + Sync,
) -> Self {
pub fn on_click(mut self, handler: impl 'static + Fn(&mut S, &mut ViewContext<S>) + Send + Sync) -> Self {
self.handlers.click = Some(Arc::new(handler));
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let icon_color = match (self.state, self.color) {

47
crates/ui2/src/components/keybinding.rs
View file

@ -1,14 +1,11 @@
use std::collections::HashSet;
use std::marker::PhantomData;
use strum::{EnumIter, IntoEnumIterator};
use crate::prelude::*;
#[derive(Element)]
pub struct Keybinding<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct Keybinding {
/// A keybinding consists of a key and a set of modifier keys.
/// More then one keybinding produces a chord.
///
@ -16,10 +13,9 @@ pub struct Keybinding<S: 'static + Send + Sync> {
keybinding: Vec<(String, ModifierKeys)>,
}
impl<S: 'static + Send + Sync> Keybinding<S> {
impl Keybinding {
pub fn new(key: String, modifiers: ModifierKeys) -> Self {
Self {
state_type: PhantomData,
keybinding: vec![(key, modifiers)],
}
}
@ -29,12 +25,11 @@ impl<S: 'static + Send + Sync> Keybinding<S> {
second_note: (String, ModifierKeys),
) -> Self {
Self {
state_type: PhantomData,
keybinding: vec![first_note, second_note],
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div()
.flex()
.gap_2()
@ -54,21 +49,17 @@ impl<S: 'static + Send + Sync> Keybinding<S> {
}
}
#[derive(Element)]
pub struct Key<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct Key {
key: SharedString,
}
impl<S: 'static + Send + Sync> Key<S> {
impl Key {
pub fn new(key: impl Into<SharedString>) -> Self {
Self {
state_type: PhantomData,
key: key.into(),
}
Self { key: key.into() }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
div()
@ -173,27 +164,19 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct KeybindingStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct KeybindingStory;
impl<S: 'static + Send + Sync + Clone> KeybindingStory<S> {
impl KeybindingStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let all_modifier_permutations = ModifierKey::iter().permutations(2);
Story::container(cx)
.child(Story::title_for::<_, Keybinding<S>>(cx))
.child(Story::title_for::<_, Keybinding>(cx))
.child(Story::label(cx, "Single Key"))
.child(Keybinding::new("Z".to_string(), ModifierKeys::new()))
.child(Story::label(cx, "Single Key with Modifier"))

36
crates/ui2/src/components/language_selector.rs
View file

@ -1,23 +1,17 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{OrderMethod, Palette, PaletteItem};
#[derive(Element)]
pub struct LanguageSelector<S: 'static + Send + Sync + Clone> {
#[derive(Component)]
pub struct LanguageSelector {
id: ElementId,
state_type: PhantomData<S>,
}
impl<S: 'static + Send + Sync + Clone> LanguageSelector<S> {
impl LanguageSelector {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
}
Self { id: id.into() }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div().id(self.id.clone()).child(
Palette::new("palette")
.items(vec![
@ -48,25 +42,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct LanguageSelectorStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct LanguageSelectorStory;
impl<S: 'static + Send + Sync + Clone> LanguageSelectorStory<S> {
impl LanguageSelectorStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, LanguageSelector<S>>(cx))
.child(Story::title_for::<_, LanguageSelector>(cx))
.child(Story::label(cx, "Default"))
.child(LanguageSelector::new("language-selector"))
}

112
crates/ui2/src/components/list.rs
View file

@ -1,5 +1,3 @@
use std::marker::PhantomData;
use gpui2::{div, relative, Div};
use crate::settings::user_settings;
@ -17,9 +15,8 @@ pub enum ListItemVariant {
Inset,
}
#[derive(Element)]
pub struct ListHeader<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct ListHeader {
label: SharedString,
left_icon: Option<Icon>,
variant: ListItemVariant,
@ -27,10 +24,9 @@ pub struct ListHeader<S: 'static + Send + Sync> {
toggleable: Toggleable,
}
impl<S: 'static + Send + Sync> ListHeader<S> {
impl ListHeader {
pub fn new(label: impl Into<SharedString>) -> Self {
Self {
state_type: PhantomData,
label: label.into(),
left_icon: None,
variant: ListItemVariant::default(),
@ -59,7 +55,7 @@ impl<S: 'static + Send + Sync> ListHeader<S> {
self
}
fn disclosure_control(&self) -> Div<S> {
fn disclosure_control<S: 'static>(&self) -> Div<S> {
let is_toggleable = self.toggleable != Toggleable::NotToggleable;
let is_toggled = Toggleable::is_toggled(&self.toggleable);
@ -92,7 +88,7 @@ impl<S: 'static + Send + Sync> ListHeader<S> {
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let is_toggleable = self.toggleable != Toggleable::NotToggleable;
@ -134,18 +130,16 @@ impl<S: 'static + Send + Sync> ListHeader<S> {
}
}
#[derive(Element)]
pub struct ListSubHeader<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct ListSubHeader {
label: SharedString,
left_icon: Option<Icon>,
variant: ListItemVariant,
}
impl<S: 'static + Send + Sync> ListSubHeader<S> {
impl ListSubHeader {
pub fn new(label: impl Into<SharedString>) -> Self {
Self {
state_type: PhantomData,
label: label.into(),
left_icon: None,
variant: ListItemVariant::default(),
@ -157,7 +151,7 @@ impl<S: 'static + Send + Sync> ListSubHeader<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
h_stack().flex_1().w_full().relative().py_1().child(
div()
.h_6()
@ -197,40 +191,40 @@ pub enum ListEntrySize {
Medium,
}
#[derive(Element)]
pub enum ListItem<S: 'static + Send + Sync> {
Entry(ListEntry<S>),
#[derive(Component)]
pub enum ListItem<S: 'static> {
Entry(ListEntry),
Details(ListDetailsEntry<S>),
Separator(ListSeparator<S>),
Header(ListSubHeader<S>),
Separator(ListSeparator),
Header(ListSubHeader),
}
impl<S: 'static + Send + Sync> From<ListEntry<S>> for ListItem<S> {
fn from(entry: ListEntry<S>) -> Self {
impl<S: 'static> From<ListEntry> for ListItem<S> {
fn from(entry: ListEntry) -> Self {
Self::Entry(entry)
}
}
impl<S: 'static + Send + Sync> From<ListDetailsEntry<S>> for ListItem<S> {
impl<S: 'static> From<ListDetailsEntry<S>> for ListItem<S> {
fn from(entry: ListDetailsEntry<S>) -> Self {
Self::Details(entry)
}
}
impl<S: 'static + Send + Sync> From<ListSeparator<S>> for ListItem<S> {
fn from(entry: ListSeparator<S>) -> Self {
impl<S: 'static> From<ListSeparator> for ListItem<S> {
fn from(entry: ListSeparator) -> Self {
Self::Separator(entry)
}
}
impl<S: 'static + Send + Sync> From<ListSubHeader<S>> for ListItem<S> {
fn from(entry: ListSubHeader<S>) -> Self {
impl<S: 'static> From<ListSubHeader> for ListItem<S> {
fn from(entry: ListSubHeader) -> Self {
Self::Header(entry)
}
}
impl<S: 'static + Send + Sync> ListItem<S> {
fn render(&mut self, view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
impl<S: 'static> ListItem<S> {
fn render(self, view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
match self {
ListItem::Entry(entry) => div().child(entry.render(view, cx)),
ListItem::Separator(separator) => div().child(separator.render(view, cx)),
@ -239,11 +233,11 @@ impl<S: 'static + Send + Sync> ListItem<S> {
}
}
pub fn new(label: Label<S>) -> Self {
pub fn new(label: Label) -> Self {
Self::Entry(ListEntry::new(label))
}
pub fn as_entry(&mut self) -> Option<&mut ListEntry<S>> {
pub fn as_entry(&mut self) -> Option<&mut ListEntry> {
if let Self::Entry(entry) = self {
Some(entry)
} else {
@ -252,11 +246,11 @@ impl<S: 'static + Send + Sync> ListItem<S> {
}
}
#[derive(Element)]
pub struct ListEntry<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct ListEntry {
disclosure_control_style: DisclosureControlVisibility,
indent_level: u32,
label: Option<Label<S>>,
label: Option<Label>,
left_content: Option<LeftContent>,
variant: ListItemVariant,
size: ListEntrySize,
@ -265,8 +259,8 @@ pub struct ListEntry<S: 'static + Send + Sync> {
overflow: OverflowStyle,
}
impl<S: 'static + Send + Sync> ListEntry<S> {
pub fn new(label: Label<S>) -> Self {
impl ListEntry {
pub fn new(label: Label) -> Self {
Self {
disclosure_control_style: DisclosureControlVisibility::default(),
indent_level: 0,
@ -344,10 +338,10 @@ impl<S: 'static + Send + Sync> ListEntry<S> {
}
}
fn disclosure_control(
fn disclosure_control<V: 'static>(
&mut self,
cx: &mut ViewContext<S>,
) -> Option<impl Element<ViewState = S>> {
cx: &mut ViewContext<V>,
) -> Option<impl Component<V>> {
let disclosure_control_icon = if let Some(ToggleState::Toggled) = self.toggle {
IconElement::new(Icon::ChevronDown)
} else {
@ -367,7 +361,7 @@ impl<S: 'static + Send + Sync> ListEntry<S> {
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let settings = user_settings(cx);
let theme = theme(cx);
@ -423,18 +417,18 @@ impl<S: 'static + Send + Sync> ListEntry<S> {
}
}
struct ListDetailsEntryHandlers<S: 'static + Send + Sync> {
struct ListDetailsEntryHandlers<S: 'static> {
click: Option<ClickHandler<S>>,
}
impl<S: 'static + Send + Sync> Default for ListDetailsEntryHandlers<S> {
impl<S: 'static> Default for ListDetailsEntryHandlers<S> {
fn default() -> Self {
Self { click: None }
}
}
#[derive(Element)]
pub struct ListDetailsEntry<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct ListDetailsEntry<S: 'static> {
label: SharedString,
meta: Option<SharedString>,
left_content: Option<LeftContent>,
@ -445,7 +439,7 @@ pub struct ListDetailsEntry<S: 'static + Send + Sync> {
seen: bool,
}
impl<S: 'static + Send + Sync> ListDetailsEntry<S> {
impl<S: 'static> ListDetailsEntry<S> {
pub fn new(label: impl Into<SharedString>) -> Self {
Self {
label: label.into(),
@ -477,7 +471,7 @@ impl<S: 'static + Send + Sync> ListDetailsEntry<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let settings = user_settings(cx);
@ -522,34 +516,30 @@ impl<S: 'static + Send + Sync> ListDetailsEntry<S> {
}
}
#[derive(Clone, Element)]
pub struct ListSeparator<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Clone, Component)]
pub struct ListSeparator;
impl<S: 'static + Send + Sync> ListSeparator<S> {
impl ListSeparator {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let theme = theme(cx);
div().h_px().w_full().bg(theme.border)
}
}
#[derive(Element)]
pub struct List<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct List<S: 'static> {
items: Vec<ListItem<S>>,
empty_message: SharedString,
header: Option<ListHeader<S>>,
header: Option<ListHeader>,
toggleable: Toggleable,
}
impl<S: 'static + Send + Sync> List<S> {
impl<S: 'static> List<S> {
pub fn new(items: Vec<ListItem<S>>) -> Self {
Self {
items,
@ -564,7 +554,7 @@ impl<S: 'static + Send + Sync> List<S> {
self
}
pub fn header(mut self, header: ListHeader<S>) -> Self {
pub fn header(mut self, header: ListHeader) -> Self {
self.header = Some(header);
self
}
@ -574,7 +564,7 @@ impl<S: 'static + Send + Sync> List<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let is_toggleable = self.toggleable != Toggleable::NotToggleable;
let is_toggled = Toggleable::is_toggled(&self.toggleable);

16
crates/ui2/src/components/modal.rs
View file

@ -1,25 +1,21 @@
use std::marker::PhantomData;
use gpui2::AnyElement;
use smallvec::SmallVec;
use crate::{h_stack, prelude::*, v_stack, Button, Icon, IconButton, Label};
#[derive(Element)]
pub struct Modal<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct Modal<S: 'static> {
id: ElementId,
state_type: PhantomData<S>,
title: Option<SharedString>,
primary_action: Option<Button<S>>,
secondary_action: Option<Button<S>>,
children: SmallVec<[AnyElement<S>; 2]>,
}
impl<S: 'static + Send + Sync> Modal<S> {
impl<S: 'static> Modal<S> {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
title: None,
primary_action: None,
secondary_action: None,
@ -42,7 +38,7 @@ impl<S: 'static + Send + Sync> Modal<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
v_stack()
@ -80,8 +76,8 @@ impl<S: 'static + Send + Sync> Modal<S> {
}
}
impl<S: 'static + Send + Sync> ParentElement for Modal<S> {
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<Self::ViewState>; 2]> {
impl<S: 'static> ParentElement<S> for Modal<S> {
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<S>; 2]> {
&mut self.children
}
}

40
crates/ui2/src/components/multi_buffer.rs
View file

@ -1,23 +1,17 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{v_stack, Buffer, Icon, IconButton, Label};
#[derive(Element)]
pub struct MultiBuffer<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
buffers: Vec<Buffer<S>>,
#[derive(Component)]
pub struct MultiBuffer {
buffers: Vec<Buffer>,
}
impl<S: 'static + Send + Sync + Clone> MultiBuffer<S> {
pub fn new(buffers: Vec<Buffer<S>>) -> Self {
Self {
state_type: PhantomData,
buffers,
}
impl MultiBuffer {
pub fn new(buffers: Vec<Buffer>) -> Self {
Self { buffers }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let theme = theme(cx);
v_stack()
@ -50,27 +44,19 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct MultiBufferStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct MultiBufferStory;
impl<S: 'static + Send + Sync + Clone> MultiBufferStory<S> {
impl MultiBufferStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let theme = theme(cx);
Story::container(cx)
.child(Story::title_for::<_, MultiBuffer<S>>(cx))
.child(Story::title_for::<_, MultiBuffer>(cx))
.child(Story::label(cx, "Default"))
.child(MultiBuffer::new(vec![
hello_world_rust_buffer_example(&theme),

12
crates/ui2/src/components/notification_toast.rs
View file

@ -1,20 +1,16 @@
use std::marker::PhantomData;
use gpui2::rems;
use crate::{h_stack, prelude::*, Icon};
#[derive(Element)]
pub struct NotificationToast<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct NotificationToast {
label: SharedString,
icon: Option<Icon>,
}
impl<S: 'static + Send + Sync + Clone> NotificationToast<S> {
impl NotificationToast {
pub fn new(label: SharedString) -> Self {
Self {
state_type: PhantomData,
label,
icon: None,
}
@ -28,7 +24,7 @@ impl<S: 'static + Send + Sync + Clone> NotificationToast<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
h_stack()

31
crates/ui2/src/components/notifications_panel.rs
View file

@ -1,23 +1,20 @@
use std::marker::PhantomData;
use crate::{prelude::*, static_new_notification_items, static_read_notification_items};
use crate::{List, ListHeader};
#[derive(Element)]
pub struct NotificationsPanel<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct NotificationsPanel {
id: ElementId,
state_type: PhantomData<S>,
}
impl<S: 'static + Send + Sync> NotificationsPanel<S> {
impl NotificationsPanel {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
div()
@ -58,25 +55,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct NotificationsPanelStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct NotificationsPanelStory;
impl<S: 'static + Send + Sync + Clone> NotificationsPanelStory<S> {
impl NotificationsPanelStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
Story::container(cx)
.child(Story::title_for::<_, NotificationsPanel<S>>(cx))
.child(Story::title_for::<_, NotificationsPanel>(cx))
.child(Story::label(cx, "Default"))
.child(
Panel::new("panel", cx).child(NotificationsPanel::new("notifications_panel")),

48
crates/ui2/src/components/palette.rs
View file

@ -1,23 +1,19 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{h_stack, v_stack, Keybinding, Label, LabelColor};
#[derive(Element)]
pub struct Palette<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct Palette {
id: ElementId,
state_type: PhantomData<S>,
input_placeholder: SharedString,
empty_string: SharedString,
items: Vec<PaletteItem<S>>,
items: Vec<PaletteItem>,
default_order: OrderMethod,
}
impl<S: 'static + Send + Sync> Palette<S> {
impl Palette {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
input_placeholder: "Find something...".into(),
empty_string: "No items found.".into(),
items: vec![],
@ -25,7 +21,7 @@ impl<S: 'static + Send + Sync> Palette<S> {
}
}
pub fn items(mut self, items: Vec<PaletteItem<S>>) -> Self {
pub fn items(mut self, items: Vec<PaletteItem>) -> Self {
self.items = items;
self
}
@ -46,7 +42,7 @@ impl<S: 'static + Send + Sync> Palette<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
v_stack()
@ -101,14 +97,14 @@ impl<S: 'static + Send + Sync> Palette<S> {
}
}
#[derive(Element)]
pub struct PaletteItem<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct PaletteItem {
pub label: SharedString,
pub sublabel: Option<SharedString>,
pub keybinding: Option<Keybinding<S>>,
pub keybinding: Option<Keybinding>,
}
impl<S: 'static + Send + Sync> PaletteItem<S> {
impl PaletteItem {
pub fn new(label: impl Into<SharedString>) -> Self {
Self {
label: label.into(),
@ -129,13 +125,13 @@ impl<S: 'static + Send + Sync> PaletteItem<S> {
pub fn keybinding<K>(mut self, keybinding: K) -> Self
where
K: Into<Option<Keybinding<S>>>,
K: Into<Option<Keybinding>>,
{
self.keybinding = keybinding.into();
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div()
.flex()
.flex_row()
@ -160,25 +156,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct PaletteStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct PaletteStory;
impl<S: 'static + Send + Sync + Clone> PaletteStory<S> {
impl PaletteStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
Story::container(cx)
.child(Story::title_for::<_, Palette<S>>(cx))
.child(Story::title_for::<_, Palette>(cx))
.child(Story::label(cx, "Default"))
.child(Palette::new("palette-1"))
.child(Story::label(cx, "With Items"))

34
crates/ui2/src/components/panel.rs
View file

@ -1,5 +1,3 @@
use std::marker::PhantomData;
use gpui2::{AbsoluteLength, AnyElement};
use smallvec::SmallVec;
@ -40,10 +38,9 @@ pub enum PanelSide {
use std::collections::HashSet;
#[derive(Element)]
pub struct Panel<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct Panel<S: 'static> {
id: ElementId,
state_type: PhantomData<S>,
current_side: PanelSide,
/// Defaults to PanelAllowedSides::LeftAndRight
allowed_sides: PanelAllowedSides,
@ -52,13 +49,12 @@ pub struct Panel<S: 'static + Send + Sync> {
children: SmallVec<[AnyElement<S>; 2]>,
}
impl<S: 'static + Send + Sync> Panel<S> {
impl<S: 'static> Panel<S> {
pub fn new(id: impl Into<ElementId>, cx: &mut WindowContext) -> Self {
let settings = user_settings(cx);
Self {
id: id.into(),
state_type: PhantomData,
current_side: PanelSide::default(),
allowed_sides: PanelAllowedSides::default(),
initial_width: *settings.default_panel_size,
@ -96,7 +92,7 @@ impl<S: 'static + Send + Sync> Panel<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let current_size = self.width.unwrap_or(self.initial_width);
@ -121,8 +117,8 @@ impl<S: 'static + Send + Sync> Panel<S> {
}
}
impl<S: 'static + Send + Sync> ParentElement for Panel<S> {
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<Self::ViewState>; 2]> {
impl<S: 'static> ParentElement<S> for Panel<S> {
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<S>; 2]> {
&mut self.children
}
}
@ -136,23 +132,15 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct PanelStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct PanelStory;
impl<S: 'static + Send + Sync + Clone> PanelStory<S> {
impl PanelStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, Panel<S>>(cx))
.child(Story::label(cx, "Default"))

56
crates/ui2/src/components/panes.rs
View file

@ -1,5 +1,3 @@
use std::marker::PhantomData;
use gpui2::{hsla, red, AnyElement, ElementId, ExternalPaths, Hsla, Length, Size};
use smallvec::SmallVec;
@ -12,25 +10,29 @@ pub enum SplitDirection {
Vertical,
}
#[derive(Element)]
pub struct Pane<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct Pane<V: 'static> {
id: ElementId,
state_type: PhantomData<S>,
size: Size<Length>,
fill: Hsla,
children: SmallVec<[AnyElement<S>; 2]>,
children: SmallVec<[AnyElement<V>; 2]>,
}
impl<S: 'static + Send + Sync> Pane<S> {
// impl<V: 'static> IntoAnyElement<V> for Pane<V> {
// fn into_any(self) -> AnyElement<V> {
// (move |view_state: &mut V, cx: &mut ViewContext<'_, '_, V>| self.render(view_state, cx))
// .into_any()
// }
// }
impl<V: 'static> Pane<V> {
pub fn new(id: impl Into<ElementId>, size: Size<Length>) -> Self {
// Fill is only here for debugging purposes, remove before release
Self {
id: id.into(),
state_type: PhantomData,
size,
fill: hsla(0.3, 0.3, 0.3, 1.),
// fill: system_color.transparent,
children: SmallVec::new(),
}
}
@ -40,7 +42,7 @@ impl<S: 'static + Send + Sync> Pane<S> {
self
}
fn render(&mut self, view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
div()
.id(self.id.clone())
.flex()
@ -49,12 +51,7 @@ impl<S: 'static + Send + Sync> Pane<S> {
.w(self.size.width)
.h(self.size.height)
.relative()
.child(
div()
.z_index(0)
.size_full()
.children(self.children.drain(..)),
)
.child(div().z_index(0).size_full().children(self.children))
.child(
div()
.z_index(1)
@ -69,40 +66,37 @@ impl<S: 'static + Send + Sync> Pane<S> {
}
}
impl<S: 'static + Send + Sync> ParentElement for Pane<S> {
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<Self::ViewState>; 2]> {
impl<V: 'static> ParentElement<V> for Pane<V> {
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
&mut self.children
}
}
#[derive(Element)]
pub struct PaneGroup<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
groups: Vec<PaneGroup<S>>,
panes: Vec<Pane<S>>,
#[derive(Component)]
pub struct PaneGroup<V: 'static> {
groups: Vec<PaneGroup<V>>,
panes: Vec<Pane<V>>,
split_direction: SplitDirection,
}
impl<S: 'static + Send + Sync> PaneGroup<S> {
pub fn new_groups(groups: Vec<PaneGroup<S>>, split_direction: SplitDirection) -> Self {
impl<V: 'static> PaneGroup<V> {
pub fn new_groups(groups: Vec<PaneGroup<V>>, split_direction: SplitDirection) -> Self {
Self {
state_type: PhantomData,
groups,
panes: Vec::new(),
split_direction,
}
}
pub fn new_panes(panes: Vec<Pane<S>>, split_direction: SplitDirection) -> Self {
pub fn new_panes(panes: Vec<Pane<V>>, split_direction: SplitDirection) -> Self {
Self {
state_type: PhantomData,
groups: Vec::new(),
panes,
split_direction,
}
}
fn render(&mut self, view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(mut self, view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let theme = theme(cx);
if !self.panes.is_empty() {
@ -112,7 +106,7 @@ impl<S: 'static + Send + Sync> PaneGroup<S> {
.gap_px()
.w_full()
.h_full()
.children(self.panes.iter_mut().map(|pane| pane.render(view, cx)));
.children(self.panes.drain(..).map(|pane| pane.render(view, cx)));
if self.split_direction == SplitDirection::Horizontal {
return el;
@ -129,7 +123,7 @@ impl<S: 'static + Send + Sync> PaneGroup<S> {
.w_full()
.h_full()
.bg(theme.editor)
.children(self.groups.iter_mut().map(|group| group.render(view, cx)));
.children(self.groups.drain(..).map(|group| group.render(view, cx)));
if self.split_direction == SplitDirection::Horizontal {
return el;

12
crates/ui2/src/components/player_stack.rs
View file

@ -1,23 +1,19 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{Avatar, Facepile, PlayerWithCallStatus};
#[derive(Element)]
pub struct PlayerStack<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct PlayerStack {
player_with_call_status: PlayerWithCallStatus,
}
impl<S: 'static + Send + Sync> PlayerStack<S> {
impl PlayerStack {
pub fn new(player_with_call_status: PlayerWithCallStatus) -> Self {
Self {
state_type: PhantomData,
player_with_call_status,
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let player = self.player_with_call_status.get_player();
self.player_with_call_status.get_call_status();

36
crates/ui2/src/components/project_panel.rs
View file

@ -1,25 +1,19 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{
static_project_panel_project_items, static_project_panel_single_items, Input, List, ListHeader,
};
#[derive(Element)]
pub struct ProjectPanel<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct ProjectPanel {
id: ElementId,
state_type: PhantomData<S>,
}
impl<S: 'static + Send + Sync> ProjectPanel<S> {
impl ProjectPanel {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
}
Self { id: id.into() }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
div()
@ -67,25 +61,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct ProjectPanelStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct ProjectPanelStory;
impl<S: 'static + Send + Sync + Clone> ProjectPanelStory<S> {
impl ProjectPanelStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, ProjectPanel<S>>(cx))
.child(Story::title_for::<_, ProjectPanel>(cx))
.child(Story::label(cx, "Default"))
.child(
Panel::new("project-panel-outer", cx)

36
crates/ui2/src/components/recent_projects.rs
View file

@ -1,23 +1,17 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{OrderMethod, Palette, PaletteItem};
#[derive(Element)]
pub struct RecentProjects<S: 'static + Send + Sync + Clone> {
#[derive(Component)]
pub struct RecentProjects {
id: ElementId,
state_type: PhantomData<S>,
}
impl<S: 'static + Send + Sync + Clone> RecentProjects<S> {
impl RecentProjects {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
}
Self { id: id.into() }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div().id(self.id.clone()).child(
Palette::new("palette")
.items(vec![
@ -44,25 +38,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct RecentProjectsStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct RecentProjectsStory;
impl<S: 'static + Send + Sync + Clone> RecentProjectsStory<S> {
impl RecentProjectsStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, RecentProjects<S>>(cx))
.child(Story::title_for::<_, RecentProjects>(cx))
.child(Story::label(cx, "Default"))
.child(RecentProjects::new("recent-projects"))
}

12
crates/ui2/src/components/status_bar.rs
View file

@ -28,8 +28,8 @@ impl Default for ToolGroup {
}
}
#[derive(Element)]
#[element(view_state = "Workspace")]
#[derive(Component)]
#[component(view_type = "Workspace")]
pub struct StatusBar {
left_tools: Option<ToolGroup>,
right_tools: Option<ToolGroup>,
@ -83,10 +83,10 @@ impl StatusBar {
}
fn render(
&mut self,
self,
view: &mut Workspace,
cx: &mut ViewContext<Workspace>,
) -> impl Element<ViewState = Workspace> {
) -> impl Component<Workspace> {
let theme = theme(cx);
div()
@ -105,7 +105,7 @@ impl StatusBar {
&self,
workspace: &mut Workspace,
cx: &WindowContext,
) -> impl Element<ViewState = Workspace> {
) -> impl Component<Workspace> {
div()
.flex()
.items_center()
@ -136,7 +136,7 @@ impl StatusBar {
&self,
workspace: &mut Workspace,
cx: &WindowContext,
) -> impl Element<ViewState = Workspace> {
) -> impl Component<Workspace> {
div()
.flex()
.items_center()

32
crates/ui2/src/components/tab.rs
View file

@ -1,11 +1,8 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{Icon, IconColor, IconElement, Label, LabelColor};
#[derive(Element, Clone)]
pub struct Tab<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
#[derive(Component, Clone)]
pub struct Tab {
id: ElementId,
title: String,
icon: Option<Icon>,
@ -22,10 +19,9 @@ struct TabDragState {
title: String,
}
impl<S: 'static + Send + Sync + Clone> Tab<S> {
impl Tab {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
state_type: PhantomData,
id: id.into(),
title: "untitled".to_string(),
icon: None,
@ -81,7 +77,7 @@ impl<S: 'static + Send + Sync + Clone> Tab<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let theme = theme(cx);
let has_fs_conflict = self.fs_status == FileSystemStatus::Conflict;
let is_deleted = self.fs_status == FileSystemStatus::Deleted;
@ -176,28 +172,20 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct TabStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct TabStory;
impl<S: 'static + Send + Sync + Clone> TabStory<S> {
impl TabStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let git_statuses = GitStatus::iter();
let fs_statuses = FileSystemStatus::iter();
Story::container(cx)
.child(Story::title_for::<_, Tab<S>>(cx))
.child(Story::title_for::<_, Tab>(cx))
.child(
h_stack().child(
v_stack()

36
crates/ui2/src/components/tab_bar.rs
View file

@ -1,22 +1,18 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{Icon, IconButton, Tab};
#[derive(Element)]
pub struct TabBar<S: 'static + Send + Sync + Clone> {
#[derive(Component)]
pub struct TabBar {
id: ElementId,
state_type: PhantomData<S>,
/// Backwards, Forwards
can_navigate: (bool, bool),
tabs: Vec<Tab<S>>,
tabs: Vec<Tab>,
}
impl<S: 'static + Send + Sync + Clone> TabBar<S> {
pub fn new(id: impl Into<ElementId>, tabs: Vec<Tab<S>>) -> Self {
impl TabBar {
pub fn new(id: impl Into<ElementId>, tabs: Vec<Tab>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
can_navigate: (false, false),
tabs,
}
@ -27,7 +23,7 @@ impl<S: 'static + Send + Sync + Clone> TabBar<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let (can_navigate_back, can_navigate_forward) = self.can_navigate;
@ -100,25 +96,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct TabBarStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct TabBarStory;
impl<S: 'static + Send + Sync + Clone> TabBarStory<S> {
impl TabBarStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, TabBar<S>>(cx))
.child(Story::title_for::<_, TabBar>(cx))
.child(Story::label(cx, "Default"))
.child(TabBar::new(
"tab-bar",

36
crates/ui2/src/components/terminal.rs
View file

@ -1,23 +1,17 @@
use std::marker::PhantomData;
use gpui2::{relative, rems, Size};
use crate::prelude::*;
use crate::{Icon, IconButton, Pane, Tab};
#[derive(Element)]
pub struct Terminal<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct Terminal;
impl<S: 'static + Send + Sync + Clone> Terminal<S> {
impl Terminal {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let can_navigate_back = true;
@ -93,25 +87,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct TerminalStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct TerminalStory;
impl<S: 'static + Send + Sync + Clone> TerminalStory<S> {
impl TerminalStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, Terminal<S>>(cx))
.child(Story::title_for::<_, Terminal>(cx))
.child(Story::label(cx, "Default"))
.child(Terminal::new())
}

36
crates/ui2/src/components/theme_selector.rs
View file

@ -1,23 +1,17 @@
use std::marker::PhantomData;
use crate::prelude::*;
use crate::{OrderMethod, Palette, PaletteItem};
#[derive(Element)]
pub struct ThemeSelector<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct ThemeSelector {
id: ElementId,
state_type: PhantomData<S>,
}
impl<S: 'static + Send + Sync> ThemeSelector<S> {
impl ThemeSelector {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
state_type: PhantomData,
}
Self { id: id.into() }
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div().child(
Palette::new(self.id.clone())
.items(vec![
@ -49,25 +43,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct ThemeSelectorStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct ThemeSelectorStory;
impl<S: 'static + Send + Sync + Clone> ThemeSelectorStory<S> {
impl ThemeSelectorStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, ThemeSelector<S>>(cx))
.child(Story::title_for::<_, ThemeSelector>(cx))
.child(Story::label(cx, "Default"))
.child(ThemeSelector::new("theme-selector"))
}

4
crates/ui2/src/components/title_bar.rs
View file

@ -87,7 +87,7 @@ impl TitleBar {
)
}
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element<ViewState = Self> {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Component<Self> {
let theme = theme(cx);
let settings = user_settings(cx);
@ -204,7 +204,7 @@ mod stories {
)
}
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element<ViewState = Self> {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Component<Self> {
Story::container(cx)
.child(Story::title_for::<_, TitleBar>(cx))
.child(Story::label(cx, "Default"))

34
crates/ui2/src/components/toast.rs
View file

@ -22,13 +22,13 @@ pub enum ToastOrigin {
/// they are actively showing the a process in progress.
///
/// Only one toast may be visible at a time.
#[derive(Element)]
pub struct Toast<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct Toast<S: 'static> {
origin: ToastOrigin,
children: SmallVec<[AnyElement<S>; 2]>,
}
impl<S: 'static + Send + Sync> Toast<S> {
impl<S: 'static> Toast<S> {
pub fn new(origin: ToastOrigin) -> Self {
Self {
origin,
@ -36,7 +36,7 @@ impl<S: 'static + Send + Sync> Toast<S> {
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let mut div = div();
@ -57,12 +57,12 @@ impl<S: 'static + Send + Sync> Toast<S> {
.shadow_md()
.overflow_hidden()
.bg(theme.elevated_surface)
.children(self.children.drain(..))
.children(self.children)
}
}
impl<S: 'static + Send + Sync> ParentElement for Toast<S> {
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<Self::ViewState>; 2]> {
impl<S: 'static> ParentElement<S> for Toast<S> {
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<S>; 2]> {
&mut self.children
}
}
@ -72,29 +72,19 @@ pub use stories::*;
#[cfg(feature = "stories")]
mod stories {
use std::marker::PhantomData;
use crate::{Label, Story};
use super::*;
#[derive(Element)]
pub struct ToastStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct ToastStory;
impl<S: 'static + Send + Sync> ToastStory<S> {
impl ToastStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
Story::container(cx)
.child(Story::title_for::<_, Toast<S>>(cx))
.child(Story::label(cx, "Default"))

45
crates/ui2/src/components/toolbar.rs
View file

@ -6,13 +6,13 @@ use crate::prelude::*;
#[derive(Clone)]
pub struct ToolbarItem {}
#[derive(Element)]
pub struct Toolbar<S: 'static + Send + Sync> {
#[derive(Component)]
pub struct Toolbar<S: 'static> {
left_items: SmallVec<[AnyElement<S>; 2]>,
right_items: SmallVec<[AnyElement<S>; 2]>,
}
impl<S: 'static + Send + Sync> Toolbar<S> {
impl<S: 'static> Toolbar<S> {
pub fn new() -> Self {
Self {
left_items: SmallVec::new(),
@ -20,41 +20,41 @@ impl<S: 'static + Send + Sync> Toolbar<S> {
}
}
pub fn left_item(mut self, child: impl IntoAnyElement<S>) -> Self
pub fn left_item(mut self, child: impl Component<S>) -> Self
where
Self: Sized,
{
self.left_items.push(child.into_any());
self.left_items.push(child.render());
self
}
pub fn left_items(mut self, iter: impl IntoIterator<Item = impl IntoAnyElement<S>>) -> Self
pub fn left_items(mut self, iter: impl IntoIterator<Item = impl Component<S>>) -> Self
where
Self: Sized,
{
self.left_items
.extend(iter.into_iter().map(|item| item.into_any()));
.extend(iter.into_iter().map(|item| item.render()));
self
}
pub fn right_item(mut self, child: impl IntoAnyElement<S>) -> Self
pub fn right_item(mut self, child: impl Component<S>) -> Self
where
Self: Sized,
{
self.right_items.push(child.into_any());
self.right_items.push(child.render());
self
}
pub fn right_items(mut self, iter: impl IntoIterator<Item = impl IntoAnyElement<S>>) -> Self
pub fn right_items(mut self, iter: impl IntoIterator<Item = impl Component<S>>) -> Self
where
Self: Sized,
{
self.right_items
.extend(iter.into_iter().map(|item| item.into_any()));
.extend(iter.into_iter().map(|item| item.render()));
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
div()
@ -72,7 +72,6 @@ pub use stories::*;
#[cfg(feature = "stories")]
mod stories {
use std::marker::PhantomData;
use std::path::PathBuf;
use std::str::FromStr;
@ -80,27 +79,19 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct ToolbarStory<S: 'static + Send + Sync + Clone> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct ToolbarStory;
impl<S: 'static + Send + Sync + Clone> ToolbarStory<S> {
impl ToolbarStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
let theme = theme(cx);
Story::container(cx)
.child(Story::title_for::<_, Toolbar<S>>(cx))
.child(Story::title_for::<_, Toolbar<V>>(cx))
.child(Story::label(cx, "Default"))
.child(
Toolbar::new()

42
crates/ui2/src/components/traffic_lights.rs
View file

@ -1,5 +1,3 @@
use std::marker::PhantomData;
use crate::prelude::*;
#[derive(Clone, Copy)]
@ -9,23 +7,21 @@ enum TrafficLightColor {
Green,
}
#[derive(Element)]
struct TrafficLight<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
struct TrafficLight {
color: TrafficLightColor,
window_has_focus: bool,
}
impl<S: 'static + Send + Sync> TrafficLight<S> {
impl TrafficLight {
fn new(color: TrafficLightColor, window_has_focus: bool) -> Self {
Self {
state_type: PhantomData,
color,
window_has_focus,
}
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
let theme = theme(cx);
let fill = match (self.window_has_focus, self.color) {
@ -39,16 +35,14 @@ impl<S: 'static + Send + Sync> TrafficLight<S> {
}
}
#[derive(Element)]
pub struct TrafficLights<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
#[derive(Component)]
pub struct TrafficLights {
window_has_focus: bool,
}
impl<S: 'static + Send + Sync> TrafficLights<S> {
impl TrafficLights {
pub fn new() -> Self {
Self {
state_type: PhantomData,
window_has_focus: true,
}
}
@ -58,7 +52,7 @@ impl<S: 'static + Send + Sync> TrafficLights<S> {
self
}
fn render(&mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Element<ViewState = S> {
fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
div()
.flex()
.items_center()
@ -87,25 +81,17 @@ mod stories {
use super::*;
#[derive(Element)]
pub struct TrafficLightsStory<S: 'static + Send + Sync> {
state_type: PhantomData<S>,
}
#[derive(Component)]
pub struct TrafficLightsStory;
impl<S: 'static + Send + Sync> TrafficLightsStory<S> {
impl TrafficLightsStory {
pub fn new() -> Self {
Self {
state_type: PhantomData,
}
Self
}
fn render(
&mut self,
_view: &mut S,
cx: &mut ViewContext<S>,
) -> impl Element<ViewState = S> {
fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
Story::container(cx)
.child(Story::title_for::<_, TrafficLights<S>>(cx))
.child(Story::title_for::<_, TrafficLights>(cx))
.child(Story::label(cx, "Default"))
.child(TrafficLights::new())
.child(Story::label(cx, "Unfocused"))

2
crates/ui2/src/components/workspace.rs
View file

@ -174,7 +174,7 @@ impl Workspace {
view(cx.entity(|cx| Self::new(cx)), Self::render)
}
pub fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element<ViewState = Self> {
pub fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Component<Self> {
let theme = old_theme(cx).clone();
// HACK: This should happen inside of `debug_toggle_user_settings`, but