Merge remote-tracking branch 'origin/callback-handles' into search2

crates/ui2/src/components/avatar.rs

@@ -7,10 +7,10 @@ pub struct Avatar {
     shape: Shape,
 }
 
-impl<V: 'static> Component<V> for Avatar {
-    type Rendered = Img<V>;
+impl Component for Avatar {
+    type Rendered = Img;
 
-    fn render(self, _view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, _: &mut WindowContext) -> Self::Rendered {
         let mut img = img();
 
         if self.shape == Shape::Circle {
@@ -51,12 +51,12 @@ mod stories {
 
     pub struct AvatarStory;
 
-    impl Render<Self> for AvatarStory {
-        type Element = Div<Self>;
+    impl Render for AvatarStory {
+        type Element = Div;
 
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
+        fn render(&mut self, cx: &mut WindowContext) -> Self::Element {
             Story::container(cx)
-                .child(Story::title_for::<_, Avatar>(cx))
+                .child(Story::title_for::<Avatar>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(Avatar::new(
                     "https://avatars.githubusercontent.com/u/1714999?v=4",

crates/ui2/src/components/button.rs

@@ -1,7 +1,7 @@
-use std::sync::Arc;
+use std::rc::Rc;
 
 use gpui::{
-    DefiniteLength, Div, Hsla, MouseButton, RenderOnce, Stateful, StatefulInteractiveElement,
+    DefiniteLength, Div, Hsla, MouseButton, MouseDownEvent, RenderOnce, StatefulInteractiveElement,
     WindowContext,
 };
 
@@ -10,19 +10,19 @@ use crate::{h_stack, Icon, IconButton, IconElement, Label, LineHeightStyle, Text
 
 /// Provides the flexibility to use either a standard
 /// button or an icon button in a given context.
-pub enum ButtonOrIconButton<V: 'static> {
-    Button(Button<V>),
-    IconButton(IconButton<V>),
+pub enum ButtonOrIconButton {
+    Button(Button),
+    IconButton(IconButton),
 }
 
-impl<V: 'static> From<Button<V>> for ButtonOrIconButton<V> {
-    fn from(value: Button<V>) -> Self {
+impl From<Button> for ButtonOrIconButton {
+    fn from(value: Button) -> Self {
         Self::Button(value)
     }
 }
 
-impl<V: 'static> From<IconButton<V>> for ButtonOrIconButton<V> {
-    fn from(value: IconButton<V>) -> Self {
+impl From<IconButton> for ButtonOrIconButton {
+    fn from(value: IconButton) -> Self {
         Self::IconButton(value)
     }
 }
@@ -64,25 +64,10 @@ impl ButtonVariant {
     }
 }
 
-pub type ClickHandler<V> = Arc<dyn Fn(&mut V, &mut ViewContext<V>)>;
-
-struct ButtonHandlers<V: 'static> {
-    click: Option<ClickHandler<V>>,
-}
-
-unsafe impl<S> Send for ButtonHandlers<S> {}
-unsafe impl<S> Sync for ButtonHandlers<S> {}
-
-impl<V: 'static> Default for ButtonHandlers<V> {
-    fn default() -> Self {
-        Self { click: None }
-    }
-}
-
 #[derive(RenderOnce)]
-pub struct Button<V: 'static> {
+pub struct Button {
     disabled: bool,
-    handlers: ButtonHandlers<V>,
+    click_handler: Option<Rc<dyn Fn(&MouseDownEvent, &mut WindowContext)>>,
     icon: Option<Icon>,
     icon_position: Option<IconPosition>,
     label: SharedString,
@@ -91,11 +76,10 @@ pub struct Button<V: 'static> {
     color: Option<TextColor>,
 }
 
-impl<V: 'static> Component<V> for Button<V> {
-    type Rendered = Stateful<V, Div<V>>;
+impl Component for Button {
+    type Rendered = gpui::Stateful<Div>;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let _view: &mut V = view;
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let (icon_color, label_color) = match (self.disabled, self.color) {
             (true, _) => (TextColor::Disabled, TextColor::Disabled),
             (_, None) => (TextColor::Default, TextColor::Default),
@@ -133,9 +117,9 @@ impl<V: 'static> Component<V> for Button<V> {
             button = button.w(width).justify_center();
         }
 
-        if let Some(click_handler) = self.handlers.click.clone() {
-            button = button.on_mouse_down(MouseButton::Left, move |state, event, cx| {
-                click_handler(state, cx);
+        if let Some(click_handler) = self.click_handler.clone() {
+            button = button.on_mouse_down(MouseButton::Left, move |event, cx| {
+                click_handler(event, cx);
             });
         }
 
@@ -143,11 +127,11 @@ impl<V: 'static> Component<V> for Button<V> {
     }
 }
 
-impl<V: 'static> Button<V> {
+impl Button {
     pub fn new(label: impl Into<SharedString>) -> Self {
         Self {
             disabled: false,
-            handlers: ButtonHandlers::default(),
+            click_handler: None,
             icon: None,
             icon_position: None,
             label: label.into(),
@@ -184,8 +168,11 @@ impl<V: 'static> Button<V> {
         self
     }
 
-    pub fn on_click(mut self, handler: ClickHandler<V>) -> Self {
-        self.handlers.click = Some(handler);
+    pub fn on_click(
+        mut self,
+        handler: impl Fn(&MouseDownEvent, &mut WindowContext) + 'static,
+    ) -> Self {
+        self.click_handler = Some(Rc::new(handler));
         self
     }
 
@@ -218,76 +205,29 @@ impl<V: 'static> Button<V> {
     fn render_icon(&self, icon_color: TextColor) -> Option<IconElement> {
         self.icon.map(|i| IconElement::new(i).color(icon_color))
     }
-
-    pub fn render(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
-        let (icon_color, label_color) = match (self.disabled, self.color) {
-            (true, _) => (TextColor::Disabled, TextColor::Disabled),
-            (_, None) => (TextColor::Default, TextColor::Default),
-            (_, Some(color)) => (TextColor::from(color), color),
-        };
-
-        let mut button = h_stack()
-            .id(SharedString::from(format!("{}", self.label)))
-            .relative()
-            .p_1()
-            .text_ui()
-            .rounded_md()
-            .bg(self.variant.bg_color(cx))
-            .cursor_pointer()
-            .hover(|style| style.bg(self.variant.bg_color_hover(cx)))
-            .active(|style| style.bg(self.variant.bg_color_active(cx)));
-
-        match (self.icon, self.icon_position) {
-            (Some(_), Some(IconPosition::Left)) => {
-                button = button
-                    .gap_1()
-                    .child(self.render_label(label_color))
-                    .children(self.render_icon(icon_color))
-            }
-            (Some(_), Some(IconPosition::Right)) => {
-                button = button
-                    .gap_1()
-                    .children(self.render_icon(icon_color))
-                    .child(self.render_label(label_color))
-            }
-            (_, _) => button = button.child(self.render_label(label_color)),
-        }
-
-        if let Some(width) = self.width {
-            button = button.w(width).justify_center();
-        }
-
-        if let Some(click_handler) = self.handlers.click.clone() {
-            button = button.on_mouse_down(MouseButton::Left, move |state, event, cx| {
-                click_handler(state, cx);
-            });
-        }
-
-        button
-    }
 }
 
 #[derive(RenderOnce)]
-pub struct ButtonGroup<V: 'static> {
-    buttons: Vec<Button<V>>,
+pub struct ButtonGroup {
+    buttons: Vec<Button>,
 }
 
-impl<V: 'static> Component<V> for ButtonGroup<V> {
-    type Rendered = Div<V>;
+impl Component for ButtonGroup {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let mut group = h_stack();
 
         for button in self.buttons.into_iter() {
-            group = group.child(button.render(view, cx));
+            group = group.child(button.render(cx));
         }
 
         group
     }
 }
 
-impl<V: 'static> ButtonGroup<V> {
-    pub fn new(buttons: Vec<Button<V>>) -> Self {
+impl ButtonGroup {
+    pub fn new(buttons: Vec<Button>) -> Self {
         Self { buttons }
     }
 }
@@ -304,14 +244,14 @@ mod stories {
 
     pub struct ButtonStory;
 
-    impl Render<Self> for ButtonStory {
-        type Element = Div<Self>;
+    impl Render for ButtonStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             let states = InteractionState::iter();
 
             Story::container(cx)
-                .child(Story::title_for::<_, Button<Self>>(cx))
+                .child(Story::title_for::<_, Button>(cx))
                 .child(
                     div()
                         .flex()
@@ -454,7 +394,7 @@ mod stories {
                 .child(
                     Button::new("Label")
                         .variant(ButtonVariant::Ghost)
-                        .on_click(Arc::new(|_view, _cx| println!("Button clicked."))),
+                        .on_click(cx.callback(|_view, _, cx| println!("Button clicked."))),
                 )
         }
     }

crates/ui2/src/components/checkbox.rs

@@ -1,10 +1,10 @@
-use gpui::{div, prelude::*, Div, Element, ElementId, RenderOnce, Stateful, Styled, ViewContext};
-use std::sync::Arc;
+use gpui::{div, prelude::*, Div, Element, ElementId, RenderOnce, Styled, WindowContext};
+
 use theme2::ActiveTheme;
 
 use crate::{Icon, IconElement, Selection, TextColor};
 
-pub type CheckHandler<V> = Arc<dyn Fn(Selection, &mut V, &mut ViewContext<V>) + Send + Sync>;
+pub type CheckHandler = Box<dyn Fn(&Selection, &mut WindowContext) + 'static>;
 
 /// # Checkbox
 ///
@@ -12,17 +12,17 @@ pub type CheckHandler<V> = Arc<dyn Fn(Selection, &mut V, &mut ViewContext<V>) +
 /// Each checkbox works independently from other checkboxes in the list,
 /// therefore checking an additional box does not affect any other selections.
 #[derive(RenderOnce)]
-pub struct Checkbox<V: 'static> {
+pub struct Checkbox {
     id: ElementId,
     checked: Selection,
     disabled: bool,
-    on_click: Option<CheckHandler<V>>,
+    on_click: Option<CheckHandler>,
 }
 
-impl<V: 'static> Component<V> for Checkbox<V> {
-    type Rendered = Stateful<V, Div<V>>;
+impl Component for Checkbox {
+    type Rendered = gpui::Stateful<Div>;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let group_id = format!("checkbox_group_{:?}", self.id);
 
         let icon = match self.checked {
@@ -137,13 +137,11 @@ impl<V: 'static> Component<V> for Checkbox<V> {
             )
             .when_some(
                 self.on_click.filter(|_| !self.disabled),
-                |this, on_click| {
-                    this.on_click(move |view, _, cx| on_click(self.checked.inverse(), view, cx))
-                },
+                |this, on_click| this.on_click(move |_, cx| on_click(&self.checked.inverse(), cx)),
             )
     }
 }
-impl<V: 'static> Checkbox<V> {
+impl Checkbox {
     pub fn new(id: impl Into<ElementId>, checked: Selection) -> Self {
         Self {
             id: id.into(),
@@ -160,13 +158,13 @@ impl<V: 'static> Checkbox<V> {
 
     pub fn on_click(
         mut self,
-        handler: impl 'static + Fn(Selection, &mut V, &mut ViewContext<V>) + Send + Sync,
+        handler: impl 'static + Fn(&Selection, &mut WindowContext) + Send + Sync,
     ) -> Self {
-        self.on_click = Some(Arc::new(handler));
+        self.on_click = Some(Box::new(handler));
         self
     }
 
-    pub fn render(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+    pub fn render(self, cx: &mut WindowContext) -> impl Element {
         let group_id = format!("checkbox_group_{:?}", self.id);
 
         let icon = match self.checked {
@@ -281,9 +279,7 @@ impl<V: 'static> Checkbox<V> {
             )
             .when_some(
                 self.on_click.filter(|_| !self.disabled),
-                |this, on_click| {
-                    this.on_click(move |view, _, cx| on_click(self.checked.inverse(), view, cx))
-                },
+                |this, on_click| this.on_click(move |_, cx| on_click(&self.checked.inverse(), cx)),
             )
     }
 }
@@ -299,8 +295,8 @@ mod stories {
 
     pub struct CheckboxStory;
 
-    impl Render<Self> for CheckboxStory {
-        type Element = Div<Self>;
+    impl Render for CheckboxStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             Story::container(cx)

crates/ui2/src/components/context_menu.rs

@@ -1,47 +1,42 @@
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use crate::{prelude::*, v_stack, List, ListItem};
-use crate::{ListEntry, ListSeparator, ListSubHeader};
+use crate::{prelude::*, v_stack, List};
+use crate::{ListItem, ListSeparator, ListSubHeader};
 use gpui::{
-    overlay, px, Action, AnchorCorner, AnyElement, AppContext, Bounds, DispatchPhase, Div,
-    EventEmitter, FocusHandle, FocusableView, LayoutId, ManagedView, Manager, MouseButton,
-    MouseDownEvent, Pixels, Point, Render, RenderOnce, View, VisualContext, WeakView,
+    overlay, px, Action, AnchorCorner, AnyElement, AppContext, Bounds, ClickEvent, DispatchPhase,
+    Div, EventEmitter, FocusHandle, FocusableView, LayoutId, ManagedView, Manager, MouseButton,
+    MouseDownEvent, Pixels, Point, Render, RenderOnce, View, VisualContext,
 };
 
-pub enum ContextMenuItem<V> {
+pub enum ContextMenuItem {
     Separator(ListSeparator),
     Header(ListSubHeader),
-    Entry(
-        ListEntry<ContextMenu<V>>,
-        Rc<dyn Fn(&mut V, &mut ViewContext<V>)>,
-    ),
+    Entry(ListItem, Rc<dyn Fn(&ClickEvent, &mut WindowContext)>),
 }
 
-pub struct ContextMenu<V> {
-    items: Vec<ContextMenuItem<V>>,
+pub struct ContextMenu {
+    items: Vec<ContextMenuItem>,
     focus_handle: FocusHandle,
-    handle: WeakView<V>,
 }
 
-impl<V: 'static> FocusableView for ContextMenu<V> {
+impl FocusableView for ContextMenu {
     fn focus_handle(&self, _cx: &AppContext) -> FocusHandle {
         self.focus_handle.clone()
     }
 }
 
-impl<V: 'static> EventEmitter<Manager> for ContextMenu<V> {}
+impl EventEmitter<Manager> for ContextMenu {}
 
-impl<V: 'static> ContextMenu<V> {
+impl ContextMenu {
     pub fn build(
-        cx: &mut ViewContext<V>,
-        f: impl FnOnce(Self, &mut ViewContext<Self>) -> Self,
+        cx: &mut WindowContext,
+        f: impl FnOnce(Self, &mut WindowContext) -> Self,
     ) -> View<Self> {
-        let handle = cx.view().downgrade();
+        // let handle = cx.view().downgrade();
         cx.build_view(|cx| {
             f(
                 Self {
-                    handle,
                     items: Default::default(),
                     focus_handle: cx.focus_handle(),
                 },
@@ -63,15 +58,15 @@ impl<V: 'static> ContextMenu<V> {
 
     pub fn entry(
         mut self,
-        view: ListEntry<Self>,
-        on_click: impl Fn(&mut V, &mut ViewContext<V>) + 'static,
+        view: ListItem,
+        on_click: impl Fn(&ClickEvent, &mut WindowContext) + 'static,
     ) -> Self {
         self.items
             .push(ContextMenuItem::Entry(view, Rc::new(on_click)));
         self
     }
 
-    pub fn action(self, view: ListEntry<Self>, action: Box<dyn Action>) -> Self {
+    pub fn action(self, view: ListItem, action: Box<dyn Action>) -> Self {
         // todo: add the keybindings to the list entry
         self.entry(view, move |_, cx| cx.dispatch_action(action.boxed_clone()))
     }
@@ -86,64 +81,66 @@ impl<V: 'static> ContextMenu<V> {
     }
 }
 
-impl<V: 'static> Render<Self> for ContextMenu<V> {
-    type Element = Div<Self>;
+impl Render for ContextMenu {
+    type Element = Div;
 
     fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
         div().elevation_2(cx).flex().flex_row().child(
             v_stack()
                 .min_w(px(200.))
                 .track_focus(&self.focus_handle)
-                .on_mouse_down_out(|this: &mut Self, _, cx| this.cancel(&Default::default(), cx))
+                .on_mouse_down_out(
+                    cx.listener(|this: &mut Self, _, cx| this.cancel(&Default::default(), cx)),
+                )
                 // .on_action(ContextMenu::select_first)
                 // .on_action(ContextMenu::select_last)
                 // .on_action(ContextMenu::select_next)
                 // .on_action(ContextMenu::select_prev)
-                .on_action(ContextMenu::confirm)
-                .on_action(ContextMenu::cancel)
+                .on_action(cx.listener(ContextMenu::confirm))
+                .on_action(cx.listener(ContextMenu::cancel))
                 .flex_none()
                 // .bg(cx.theme().colors().elevated_surface_background)
                 // .border()
                 // .border_color(cx.theme().colors().border)
-                .child(List::new(
-                    self.items
-                        .iter()
-                        .map(|item| match item {
-                            ContextMenuItem::Separator(separator) => {
-                                ListItem::Separator(separator.clone())
-                            }
-                            ContextMenuItem::Header(header) => ListItem::Header(header.clone()),
-                            ContextMenuItem::Entry(entry, callback) => {
-                                let callback = callback.clone();
-                                let handle = self.handle.clone();
-                                ListItem::Entry(entry.clone().on_click(move |this, cx| {
-                                    handle.update(cx, |view, cx| callback(view, cx)).ok();
-                                    cx.emit(Manager::Dismiss);
-                                }))
-                            }
-                        })
-                        .collect(),
-                )),
+                .child(
+                    List::new().children(self.items.iter().map(|item| match item {
+                        ContextMenuItem::Separator(separator) => {
+                            separator.clone().render_into_any()
+                        }
+                        ContextMenuItem::Header(header) => header.clone().render_into_any(),
+                        ContextMenuItem::Entry(entry, callback) => {
+                            let callback = callback.clone();
+                            let dismiss = cx.listener(|_, _, cx| cx.emit(Manager::Dismiss));
+
+                            entry
+                                .clone()
+                                .on_click(move |event, cx| {
+                                    callback(event, cx);
+                                    dismiss(event, cx)
+                                })
+                                .render_into_any()
+                        }
+                    })),
+                ),
         )
     }
 }
 
-pub struct MenuHandle<V: 'static, M: ManagedView> {
+pub struct MenuHandle<M: ManagedView> {
     id: ElementId,
-    child_builder: Option<Box<dyn FnOnce(bool) -> AnyElement<V> + 'static>>,
-    menu_builder: Option<Rc<dyn Fn(&mut V, &mut ViewContext<V>) -> View<M> + 'static>>,
-
+    child_builder: Option<Box<dyn FnOnce(bool) -> AnyElement + 'static>>,
+    menu_builder: Option<Rc<dyn Fn(&mut WindowContext) -> View<M> + 'static>>,
     anchor: Option<AnchorCorner>,
     attach: Option<AnchorCorner>,
 }
 
-impl<V: 'static, M: ManagedView> MenuHandle<V, M> {
-    pub fn menu(mut self, f: impl Fn(&mut V, &mut ViewContext<V>) -> View<M> + 'static) -> Self {
+impl<M: ManagedView> MenuHandle<M> {
+    pub fn menu(mut self, f: impl Fn(&mut WindowContext) -> View<M> + 'static) -> Self {
         self.menu_builder = Some(Rc::new(f));
         self
     }
 
-    pub fn child<R: RenderOnce<V>>(mut self, f: impl FnOnce(bool) -> R + 'static) -> Self {
+    pub fn child<R: RenderOnce>(mut self, f: impl FnOnce(bool) -> R + 'static) -> Self {
         self.child_builder = Some(Box::new(|b| f(b).render_once().into_any()));
         self
     }
@@ -162,7 +159,7 @@ impl<V: 'static, M: ManagedView> MenuHandle<V, M> {
     }
 }
 
-pub fn menu_handle<V: 'static, M: ManagedView>(id: impl Into<ElementId>) -> MenuHandle<V, M> {
+pub fn menu_handle<M: ManagedView>(id: impl Into<ElementId>) -> MenuHandle<M> {
     MenuHandle {
         id: id.into(),
         child_builder: None,
@@ -172,21 +169,20 @@ pub fn menu_handle<V: 'static, M: ManagedView>(id: impl Into<ElementId>) -> Menu
     }
 }
 
-pub struct MenuHandleState<V, M> {
+pub struct MenuHandleState<M> {
     menu: Rc<RefCell<Option<View<M>>>>,
     position: Rc<RefCell<Point<Pixels>>>,
     child_layout_id: Option<LayoutId>,
-    child_element: Option<AnyElement<V>>,
-    menu_element: Option<AnyElement<V>>,
+    child_element: Option<AnyElement>,
+    menu_element: Option<AnyElement>,
 }
-impl<V: 'static, M: ManagedView> Element<V> for MenuHandle<V, M> {
-    type State = MenuHandleState<V, M>;
+impl<M: ManagedView> Element for MenuHandle<M> {
+    type State = MenuHandleState<M>;
 
     fn layout(
         &mut self,
-        view_state: &mut V,
         element_state: Option<Self::State>,
-        cx: &mut crate::ViewContext<V>,
+        cx: &mut WindowContext,
     ) -> (gpui::LayoutId, Self::State) {
         let (menu, position) = if let Some(element_state) = element_state {
             (element_state.menu, element_state.position)
@@ -197,14 +193,14 @@ impl<V: 'static, M: ManagedView> Element<V> for MenuHandle<V, M> {
         let mut menu_layout_id = None;
 
         let menu_element = menu.borrow_mut().as_mut().map(|menu| {
-            let mut overlay = overlay::<V>().snap_to_window();
+            let mut overlay = overlay().snap_to_window();
             if let Some(anchor) = self.anchor {
                 overlay = overlay.anchor(anchor);
             }
             overlay = overlay.position(*position.borrow());
 
             let mut element = overlay.child(menu.clone()).into_any();
-            menu_layout_id = Some(element.layout(view_state, cx));
+            menu_layout_id = Some(element.layout(cx));
             element
         });
 
@@ -215,7 +211,7 @@ impl<V: 'static, M: ManagedView> Element<V> for MenuHandle<V, M> {
 
         let child_layout_id = child_element
             .as_mut()
-            .map(|child_element| child_element.layout(view_state, cx));
+            .map(|child_element| child_element.layout(cx));
 
         let layout_id = cx.request_layout(
             &gpui::Style::default(),
@@ -237,16 +233,15 @@ impl<V: 'static, M: ManagedView> Element<V> for MenuHandle<V, M> {
     fn paint(
         self,
         bounds: Bounds<gpui::Pixels>,
-        view_state: &mut V,
         element_state: &mut Self::State,
-        cx: &mut crate::ViewContext<V>,
+        cx: &mut WindowContext,
     ) {
         if let Some(child) = element_state.child_element.take() {
-            child.paint(view_state, cx);
+            child.paint(cx);
         }
 
         if let Some(menu) = element_state.menu_element.take() {
-            menu.paint(view_state, cx);
+            menu.paint(cx);
             return;
         }
 
@@ -258,7 +253,7 @@ impl<V: 'static, M: ManagedView> Element<V> for MenuHandle<V, M> {
         let attach = self.attach.clone();
         let child_layout_id = element_state.child_layout_id.clone();
 
-        cx.on_mouse_event(move |view_state, event: &MouseDownEvent, phase, cx| {
+        cx.on_mouse_event(move |event: &MouseDownEvent, phase, cx| {
             if phase == DispatchPhase::Bubble
                 && event.button == MouseButton::Right
                 && bounds.contains_point(&event.position)
@@ -266,9 +261,9 @@ impl<V: 'static, M: ManagedView> Element<V> for MenuHandle<V, M> {
                 cx.stop_propagation();
                 cx.prevent_default();
 
-                let new_menu = (builder)(view_state, cx);
+                let new_menu = (builder)(cx);
                 let menu2 = menu.clone();
-                cx.subscribe(&new_menu, move |this, modal, e, cx| match e {
+                cx.subscribe(&new_menu, move |modal, e, cx| match e {
                     &Manager::Dismiss => {
                         *menu2.borrow_mut() = None;
                         cx.notify();
@@ -291,7 +286,7 @@ impl<V: 'static, M: ManagedView> Element<V> for MenuHandle<V, M> {
     }
 }
 
-impl<V: 'static, M: ManagedView> RenderOnce<V> for MenuHandle<V, M> {
+impl<M: ManagedView> RenderOnce for MenuHandle<M> {
     type Element = Self;
 
     fn element_id(&self) -> Option<gpui::ElementId> {
@@ -314,28 +309,31 @@ mod stories {
 
     actions!(PrintCurrentDate, PrintBestFood);
 
-    fn build_menu<V: Render<V>>(
-        cx: &mut ViewContext<V>,
+    fn build_menu<V: Render>(
+        cx: &mut WindowContext,
         header: impl Into<SharedString>,
-    ) -> View<ContextMenu<V>> {
-        let handle = cx.view().clone();
+    ) -> View<ContextMenu> {
         ContextMenu::build(cx, |menu, _| {
             menu.header(header)
                 .separator()
-                .entry(ListEntry::new(Label::new("Print current time")), |v, cx| {
-                    println!("dispatching PrintCurrentTime action");
-                    cx.dispatch_action(PrintCurrentDate.boxed_clone())
-                })
-                .entry(ListEntry::new(Label::new("Print best food")), |v, cx| {
-                    cx.dispatch_action(PrintBestFood.boxed_clone())
-                })
+                .entry(
+                    ListItem::new("Print current time", Label::new("Print current time")),
+                    |v, cx| {
+                        println!("dispatching PrintCurrentTime action");
+                        cx.dispatch_action(PrintCurrentDate.boxed_clone())
+                    },
+                )
+                .entry(
+                    ListItem::new("Print best food", Label::new("Print best food")),
+                    |v, cx| cx.dispatch_action(PrintBestFood.boxed_clone()),
+                )
         })
     }
 
     pub struct ContextMenuStory;
 
-    impl Render<Self> for ContextMenuStory {
-        type Element = Div<Self>;
+    impl Render for ContextMenuStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             Story::container(cx)

crates/ui2/src/components/details.rs

@@ -2,16 +2,16 @@ use crate::prelude::*;
 use crate::{v_stack, ButtonGroup};
 
 #[derive(RenderOnce)]
-pub struct Details<V: 'static> {
+pub struct Details {
     text: &'static str,
     meta: Option<&'static str>,
-    actions: Option<ButtonGroup<V>>,
+    actions: Option<ButtonGroup>,
 }
 
-impl<V: 'static> Component<V> for Details<V> {
-    type Rendered = Div<V>;
+impl Component for Details {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         v_stack()
             .p_1()
             .gap_0p5()
@@ -24,7 +24,7 @@ impl<V: 'static> Component<V> for Details<V> {
     }
 }
 
-impl<V: 'static> Details<V> {
+impl Details {
     pub fn new(text: &'static str) -> Self {
         Self {
             text,
@@ -38,7 +38,7 @@ impl<V: 'static> Details<V> {
         self
     }
 
-    pub fn actions(mut self, actions: ButtonGroup<V>) -> Self {
+    pub fn actions(mut self, actions: ButtonGroup) -> Self {
         self.actions = Some(actions);
         self
     }
@@ -56,8 +56,8 @@ mod stories {
 
     pub struct DetailsStory;
 
-    impl Render<Self> for DetailsStory {
-        type Element = Div<Self>;
+    impl Render for DetailsStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             Story::container(cx)

crates/ui2/src/components/divider.rs

@@ -13,10 +13,10 @@ pub struct Divider {
     inset: bool,
 }
 
-impl<V: 'static> Component<V> for Divider {
-    type Rendered = Div<V>;
+impl Component for Divider {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         div()
             .map(|this| match self.direction {
                 DividerDirection::Horizontal => {
@@ -50,7 +50,7 @@ impl Divider {
         self
     }
 
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+    fn render(self, cx: &mut WindowContext) -> impl Element {
         div()
             .map(|this| match self.direction {
                 DividerDirection::Horizontal => {

crates/ui2/src/components/elevated_surface.rs

@@ -5,7 +5,7 @@ use crate::{prelude::*, v_stack};
 /// Create an elevated surface.
 ///
 /// Must be used inside of a relative parent element
-pub fn elevated_surface<V: 'static>(level: ElevationIndex, cx: &mut ViewContext<V>) -> Div<V> {
+pub fn elevated_surface(level: ElevationIndex, cx: &mut WindowContext) -> Div {
     let colors = cx.theme().colors();
 
     // let shadow = BoxShadow {
@@ -23,6 +23,6 @@ pub fn elevated_surface<V: 'static>(level: ElevationIndex, cx: &mut ViewContext<
         .shadow(level.shadow())
 }
 
-pub fn modal<V: 'static>(cx: &mut ViewContext<V>) -> Div<V> {
+pub fn modal(cx: &mut WindowContext) -> Div {
     elevated_surface(ElevationIndex::ModalSurface, cx)
 }

crates/ui2/src/components/facepile.rs

@@ -6,10 +6,10 @@ pub struct Facepile {
     players: Vec<Player>,
 }
 
-impl<V: 'static> Component<V> for Facepile {
-    type Rendered = Div<V>;
+impl Component for Facepile {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let player_count = self.players.len();
         let player_list = self.players.iter().enumerate().map(|(ix, player)| {
             let isnt_last = ix < player_count - 1;
@@ -42,8 +42,8 @@ mod stories {
 
     pub struct FacepileStory;
 
-    impl Render<Self> for FacepileStory {
-        type Element = Div<Self>;
+    impl Render for FacepileStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             let players = static_players();

crates/ui2/src/components/icon.rs

@@ -140,10 +140,10 @@ pub struct IconElement {
     size: IconSize,
 }
 
-impl<V: 'static> Component<V> for IconElement {
-    type Rendered = Svg<V>;
+impl Component for IconElement {
+    type Rendered = Svg;
 
-    fn render(self, _view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let svg_size = match self.size {
             IconSize::Small => rems(0.75),
             IconSize::Medium => rems(0.9375),
@@ -184,7 +184,7 @@ impl IconElement {
         self
     }
 
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+    fn render(self, cx: &mut WindowContext) -> impl Element {
         let svg_size = match self.size {
             IconSize::Small => rems(0.75),
             IconSize::Medium => rems(0.9375),
@@ -212,8 +212,8 @@ mod stories {
 
     pub struct IconStory;
 
-    impl Render<Self> for IconStory {
-        type Element = Div<Self>;
+    impl Render for IconStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             let icons = Icon::iter();

crates/ui2/src/components/icon_button.rs

@@ -1,33 +1,22 @@
-use crate::{h_stack, prelude::*, ClickHandler, Icon, IconElement};
-use gpui::{prelude::*, Action, AnyView, Div, MouseButton, Stateful};
-use std::sync::Arc;
-
-struct IconButtonHandlers<V: 'static> {
-    click: Option<ClickHandler<V>>,
-}
-
-impl<V: 'static> Default for IconButtonHandlers<V> {
-    fn default() -> Self {
-        Self { click: None }
-    }
-}
+use crate::{h_stack, prelude::*, Icon, IconElement};
+use gpui::{prelude::*, Action, AnyView, Div, MouseButton, MouseDownEvent, Stateful};
 
 #[derive(RenderOnce)]
-pub struct IconButton<V: 'static> {
+pub struct IconButton {
     id: ElementId,
     icon: Icon,
     color: TextColor,
     variant: ButtonVariant,
     state: InteractionState,
     selected: bool,
-    tooltip: Option<Box<dyn Fn(&mut V, &mut ViewContext<V>) -> AnyView + 'static>>,
-    handlers: IconButtonHandlers<V>,
+    tooltip: Option<Box<dyn Fn(&mut WindowContext) -> AnyView + 'static>>,
+    on_mouse_down: Option<Box<dyn Fn(&MouseDownEvent, &mut WindowContext) + 'static>>,
 }
 
-impl<V: 'static> Component<V> for IconButton<V> {
-    type Rendered = Stateful<V, Div<V>>;
+impl Component for IconButton {
+    type Rendered = Stateful<Div>;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let icon_color = match (self.state, self.color) {
             (InteractionState::Disabled, _) => TextColor::Disabled,
             (InteractionState::Active, _) => TextColor::Selected,
@@ -65,16 +54,16 @@ impl<V: 'static> Component<V> for IconButton<V> {
             .active(|style| style.bg(bg_active_color))
             .child(IconElement::new(self.icon).color(icon_color));
 
-        if let Some(click_handler) = self.handlers.click.clone() {
-            button = button.on_mouse_down(MouseButton::Left, move |state, event, cx| {
+        if let Some(click_handler) = self.on_mouse_down {
+            button = button.on_mouse_down(MouseButton::Left, move |event, cx| {
                 cx.stop_propagation();
-                click_handler(state, cx);
+                click_handler(event, cx);
             })
         }
 
         if let Some(tooltip) = self.tooltip {
             if !self.selected {
-                button = button.tooltip(move |view: &mut V, cx| (tooltip)(view, cx))
+                button = button.tooltip(move |cx| tooltip(cx))
             }
         }
 
@@ -82,7 +71,7 @@ impl<V: 'static> Component<V> for IconButton<V> {
     }
 }
 
-impl<V: 'static> IconButton<V> {
+impl IconButton {
     pub fn new(id: impl Into<ElementId>, icon: Icon) -> Self {
         Self {
             id: id.into(),
@@ -92,7 +81,7 @@ impl<V: 'static> IconButton<V> {
             state: InteractionState::default(),
             selected: false,
             tooltip: None,
-            handlers: IconButtonHandlers::default(),
+            on_mouse_down: None,
         }
     }
 
@@ -121,16 +110,16 @@ impl<V: 'static> IconButton<V> {
         self
     }
 
-    pub fn tooltip(
-        mut self,
-        tooltip: impl Fn(&mut V, &mut ViewContext<V>) -> AnyView + 'static,
-    ) -> Self {
+    pub fn tooltip(mut self, tooltip: impl Fn(&mut WindowContext) -> AnyView + 'static) -> Self {
         self.tooltip = Some(Box::new(tooltip));
         self
     }
 
-    pub fn on_click(mut self, handler: impl 'static + Fn(&mut V, &mut ViewContext<V>)) -> Self {
-        self.handlers.click = Some(Arc::new(handler));
+    pub fn on_click(
+        mut self,
+        handler: impl 'static + Fn(&MouseDownEvent, &mut WindowContext),
+    ) -> Self {
+        self.on_mouse_down = Some(Box::new(handler));
         self
     }
 

crates/ui2/src/components/indicator.rs

@@ -4,10 +4,10 @@ use gpui::{px, Div, RenderOnce};
 #[derive(RenderOnce)]
 pub struct UnreadIndicator;
 
-impl<V: 'static> Component<V> for UnreadIndicator {
-    type Rendered = Div<V>;
+impl Component for UnreadIndicator {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         div()
             .rounded_full()
             .border_2()
@@ -24,7 +24,7 @@ impl UnreadIndicator {
         Self
     }
 
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+    fn render(self, cx: &mut WindowContext) -> impl Element {
         div()
             .rounded_full()
             .border_2()

crates/ui2/src/components/input.rs

@@ -18,10 +18,10 @@ pub struct Input {
     is_active: bool,
 }
 
-impl<V: 'static> Component<V> for Input {
-    type Rendered = Stateful<V, Div<V>>;
+impl Component for Input {
+    type Rendered = Stateful<Div>;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let (input_bg, input_hover_bg, input_active_bg) = match self.variant {
             InputVariant::Ghost => (
                 cx.theme().colors().ghost_element_background,
@@ -118,8 +118,8 @@ mod stories {
 
     pub struct InputStory;
 
-    impl Render<Self> for InputStory {
-        type Element = Div<Self>;
+    impl Render for InputStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             Story::container(cx)

crates/ui2/src/components/keybinding.rs

@@ -10,10 +10,10 @@ pub struct KeyBinding {
     key_binding: gpui::KeyBinding,
 }
 
-impl<V: 'static> Component<V> for KeyBinding {
-    type Rendered = Div<V>;
+impl Component for KeyBinding {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         div()
             .flex()
             .gap_2()
@@ -49,11 +49,10 @@ pub struct Key {
     key: SharedString,
 }
 
-impl<V: 'static> Component<V> for Key {
-    type Rendered = Div<V>;
+impl Component for Key {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let _view: &mut V = view;
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         div()
             .px_2()
             .py_0()
@@ -89,8 +88,8 @@ mod stories {
         gpui::KeyBinding::new(key, NoAction {}, None)
     }
 
-    impl Render<Self> for KeybindingStory {
-        type Element = Div<Self>;
+    impl Render for KeybindingStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             let all_modifier_permutations =

crates/ui2/src/components/label.rs

@@ -68,10 +68,10 @@ pub struct Label {
     strikethrough: bool,
 }
 
-impl<V: 'static> Component<V> for Label {
-    type Rendered = Div<V>;
+impl Component for Label {
+    type Rendered = Div;
 
-    fn render(self, _view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         div()
             .when(self.strikethrough, |this| {
                 this.relative().child(
@@ -136,10 +136,10 @@ pub struct HighlightedLabel {
     strikethrough: bool,
 }
 
-impl<V: 'static> Component<V> for HighlightedLabel {
-    type Rendered = Div<V>;
+impl Component for HighlightedLabel {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let highlight_color = cx.theme().colors().text_accent;
         let mut text_style = cx.text_style().clone();
 
@@ -242,8 +242,8 @@ mod stories {
 
     pub struct LabelStory;
 
-    impl Render<Self> for LabelStory {
-        type Element = Div<Self>;
+    impl Render for LabelStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             Story::container(cx)

crates/ui2/src/components/list.rs

@@ -1,7 +1,9 @@
-use gpui::{div, Div, RenderOnce, Stateful, StatefulInteractiveElement};
+use gpui::{
+    div, px, AnyElement, ClickEvent, Div, RenderOnce, Stateful, StatefulInteractiveElement,
+};
+use smallvec::SmallVec;
 use std::rc::Rc;
 
-use crate::settings::user_settings;
 use crate::{
     disclosure_control, h_stack, v_stack, Avatar, Icon, IconElement, IconSize, Label, Toggle,
 };
@@ -32,10 +34,10 @@ pub struct ListHeader {
     toggle: Toggle,
 }
 
-impl<V: 'static> Component<V> for ListHeader {
-    type Rendered = Div<V>;
+impl Component for ListHeader {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let disclosure_control = disclosure_control(self.toggle);
 
         let meta = match self.meta {
@@ -117,7 +119,7 @@ impl ListHeader {
     }
 
     // before_ship!("delete")
-    // fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+    // fn render<V: 'static>(self,  cx: &mut WindowContext) -> impl Element<V> {
     //     let disclosure_control = disclosure_control(self.toggle);
 
     //     let meta = match self.meta {
@@ -177,7 +179,7 @@ impl ListHeader {
     // }
 }
 
-#[derive(Clone)]
+#[derive(RenderOnce, Clone)]
 pub struct ListSubHeader {
     label: SharedString,
     left_icon: Option<Icon>,
@@ -197,8 +199,12 @@ impl ListSubHeader {
         self.left_icon = left_icon;
         self
     }
+}
 
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+impl Component for ListSubHeader {
+    type Rendered = Div;
+
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         h_stack().flex_1().w_full().relative().py_1().child(
             div()
                 .h_6()
@@ -232,55 +238,9 @@ pub enum ListEntrySize {
     Medium,
 }
 
-#[derive(Clone)]
-pub enum ListItem<V: 'static> {
-    Entry(ListEntry<V>),
-    Separator(ListSeparator),
-    Header(ListSubHeader),
-}
-
-impl<V: 'static> From<ListEntry<V>> for ListItem<V> {
-    fn from(entry: ListEntry<V>) -> Self {
-        Self::Entry(entry)
-    }
-}
-
-impl<V: 'static> From<ListSeparator> for ListItem<V> {
-    fn from(entry: ListSeparator) -> Self {
-        Self::Separator(entry)
-    }
-}
-
-impl<V: 'static> From<ListSubHeader> for ListItem<V> {
-    fn from(entry: ListSubHeader) -> Self {
-        Self::Header(entry)
-    }
-}
-
-impl<V: 'static> ListItem<V> {
-    pub fn new(label: Label) -> Self {
-        Self::Entry(ListEntry::new(label))
-    }
-
-    pub fn as_entry(&mut self) -> Option<&mut ListEntry<V>> {
-        if let Self::Entry(entry) = self {
-            Some(entry)
-        } else {
-            None
-        }
-    }
-
-    fn render(self, view: &mut V, ix: usize, cx: &mut ViewContext<V>) -> Div<V> {
-        match self {
-            ListItem::Entry(entry) => div().child(entry.render(ix, cx)),
-            ListItem::Separator(separator) => div().child(separator.render(view, cx)),
-            ListItem::Header(header) => div().child(header.render(view, cx)),
-        }
-    }
-}
-
-// #[derive(RenderOnce)]
-pub struct ListEntry<V> {
+#[derive(RenderOnce)]
+pub struct ListItem {
+    id: ElementId,
     disabled: bool,
     // TODO: Reintroduce this
     // disclosure_control_style: DisclosureControlVisibility,
@@ -291,12 +251,13 @@ pub struct ListEntry<V> {
     size: ListEntrySize,
     toggle: Toggle,
     variant: ListItemVariant,
-    on_click: Option<Rc<dyn Fn(&mut V, &mut ViewContext<V>) + 'static>>,
+    on_click: Option<Rc<dyn Fn(&ClickEvent, &mut WindowContext) + 'static>>,
 }
 
-impl<V> Clone for ListEntry<V> {
+impl Clone for ListItem {
     fn clone(&self) -> Self {
         Self {
+            id: self.id.clone(),
             disabled: self.disabled,
             indent_level: self.indent_level,
             label: self.label.clone(),
@@ -310,9 +271,10 @@ impl<V> Clone for ListEntry<V> {
     }
 }
 
-impl<V: 'static> ListEntry<V> {
-    pub fn new(label: Label) -> Self {
+impl ListItem {
+    pub fn new(id: impl Into<ElementId>, label: Label) -> Self {
         Self {
+            id: id.into(),
             disabled: false,
             indent_level: 0,
             label,
@@ -325,7 +287,7 @@ impl<V: 'static> ListEntry<V> {
         }
     }
 
-    pub fn on_click(mut self, handler: impl Fn(&mut V, &mut ViewContext<V>) + 'static) -> Self {
+    pub fn on_click(mut self, handler: impl Fn(&ClickEvent, &mut WindowContext) + 'static) -> Self {
         self.on_click = Some(Rc::new(handler));
         self
     }
@@ -364,10 +326,12 @@ impl<V: 'static> ListEntry<V> {
         self.size = size;
         self
     }
+}
 
-    fn render(self, ix: usize, cx: &mut ViewContext<V>) -> Stateful<V, Div<V>> {
-        let settings = user_settings(cx);
+impl Component for ListItem {
+    type Rendered = Stateful<Div>;
 
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let left_content = match self.left_slot.clone() {
             Some(GraphicSlot::Icon(i)) => Some(
                 h_stack().child(
@@ -386,7 +350,7 @@ impl<V: 'static> ListEntry<V> {
             ListEntrySize::Medium => div().h_7(),
         };
         div()
-            .id(ix)
+            .id(self.id)
             .relative()
             .hover(|mut style| {
                 style.background = Some(cx.theme().colors().editor_background.into());
@@ -394,10 +358,9 @@ impl<V: 'static> ListEntry<V> {
             })
             .on_click({
                 let on_click = self.on_click.clone();
-
-                move |view: &mut V, event, cx| {
+                move |event, cx| {
                     if let Some(on_click) = &on_click {
-                        (on_click)(view, cx)
+                        (on_click)(event, cx)
                     }
                 }
             })
@@ -413,7 +376,7 @@ impl<V: 'static> ListEntry<V> {
                     // .ml(rems(0.75 * self.indent_level as f32))
                     .children((0..self.indent_level).map(|_| {
                         div()
-                            .w(*settings.list_indent_depth)
+                            .w(px(4.))
                             .h_full()
                             .flex()
                             .justify_center()
@@ -444,35 +407,30 @@ impl ListSeparator {
     }
 }
 
-impl<V: 'static> Component<V> for ListSeparator {
-    type Rendered = Div<V>;
+impl Component for ListSeparator {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         div().h_px().w_full().bg(cx.theme().colors().border_variant)
     }
 }
 
 #[derive(RenderOnce)]
-pub struct List<V: 'static> {
-    items: Vec<ListItem<V>>,
+pub struct List {
     /// Message to display when the list is empty
     /// Defaults to "No items"
     empty_message: SharedString,
     header: Option<ListHeader>,
     toggle: Toggle,
+    children: SmallVec<[AnyElement; 2]>,
 }
 
-impl<V: 'static> Component<V> for List<V> {
-    type Rendered = Div<V>;
+impl Component for List {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let list_content = match (self.items.is_empty(), self.toggle) {
-            (false, _) => div().children(
-                self.items
-                    .into_iter()
-                    .enumerate()
-                    .map(|(ix, item)| item.render(view, ix, cx)),
-            ),
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
+        let list_content = match (self.children.is_empty(), self.toggle) {
+            (false, _) => div().children(self.children),
             (true, Toggle::Toggled(false)) => div(),
             (true, _) => {
                 div().child(Label::new(self.empty_message.clone()).color(TextColor::Muted))
@@ -487,13 +445,13 @@ impl<V: 'static> Component<V> for List<V> {
     }
 }
 
-impl<V: 'static> List<V> {
-    pub fn new(items: Vec<ListItem<V>>) -> Self {
+impl List {
+    pub fn new() -> Self {
         Self {
-            items,
             empty_message: "No items".into(),
             header: None,
             toggle: Toggle::NotToggleable,
+            children: SmallVec::new(),
         }
     }
 
@@ -511,25 +469,10 @@ impl<V: 'static> List<V> {
         self.toggle = toggle;
         self
     }
+}
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
-        let list_content = match (self.items.is_empty(), self.toggle) {
-            (false, _) => div().children(
-                self.items
-                    .into_iter()
-                    .enumerate()
-                    .map(|(ix, item)| item.render(view, ix, cx)),
-            ),
-            (true, Toggle::Toggled(false)) => div(),
-            (true, _) => {
-                div().child(Label::new(self.empty_message.clone()).color(TextColor::Muted))
-            }
-        };
-
-        v_stack()
-            .w_full()
-            .py_1()
-            .children(self.header.map(|header| header))
-            .child(list_content)
+impl ParentElement for List {
+    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
+        &mut self.children
     }
 }

crates/ui2/src/components/modal.rs

@@ -1,22 +1,21 @@
-use gpui::{AnyElement, Div, RenderOnce, Stateful};
+use gpui::{AnyElement, Div, RenderOnce};
 use smallvec::SmallVec;
 
 use crate::{h_stack, prelude::*, v_stack, Button, Icon, IconButton, Label};
 
 #[derive(RenderOnce)]
-pub struct Modal<V: 'static> {
+pub struct Modal {
     id: ElementId,
     title: Option<SharedString>,
-    primary_action: Option<Button<V>>,
-    secondary_action: Option<Button<V>>,
-    children: SmallVec<[AnyElement<V>; 2]>,
+    primary_action: Option<Button>,
+    secondary_action: Option<Button>,
+    children: SmallVec<[AnyElement; 2]>,
 }
 
-impl<V: 'static> Component<V> for Modal<V> {
-    type Rendered = Stateful<V, Div<V>>;
+impl Component for Modal {
+    type Rendered = gpui::Stateful<Div>;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let _view: &mut V = view;
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         v_stack()
             .id(self.id.clone())
             .w_96()
@@ -52,7 +51,7 @@ impl<V: 'static> Component<V> for Modal<V> {
     }
 }
 
-impl<V: 'static> Modal<V> {
+impl Modal {
     pub fn new(id: impl Into<ElementId>) -> Self {
         Self {
             id: id.into(),
@@ -68,19 +67,19 @@ impl<V: 'static> Modal<V> {
         self
     }
 
-    pub fn primary_action(mut self, action: Button<V>) -> Self {
+    pub fn primary_action(mut self, action: Button) -> Self {
         self.primary_action = Some(action);
         self
     }
 
-    pub fn secondary_action(mut self, action: Button<V>) -> Self {
+    pub fn secondary_action(mut self, action: Button) -> Self {
         self.secondary_action = Some(action);
         self
     }
 }
 
-impl<V: 'static> ParentElement<V> for Modal<V> {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
+impl ParentElement for Modal {
+    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
         &mut self.children
     }
 }

crates/ui2/src/components/notification_toast.rs

@@ -22,7 +22,7 @@ impl NotificationToast {
         self
     }
 
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+    fn render(self, cx: &mut WindowContext) -> impl Element {
         h_stack()
             .z_index(5)
             .absolute()

crates/ui2/src/components/palette.rs

@@ -1,7 +1,6 @@
 use crate::{h_stack, prelude::*, v_stack, KeyBinding, Label};
 use gpui::prelude::*;
 use gpui::Div;
-use gpui::Stateful;
 
 #[derive(RenderOnce)]
 pub struct Palette {
@@ -12,10 +11,10 @@ pub struct Palette {
     default_order: OrderMethod,
 }
 
-impl<V: 'static> Component<V> for Palette {
-    type Rendered = Stateful<V, Div<V>>;
+impl Component for Palette {
+    type Rendered = gpui::Stateful<Div>;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         v_stack()
             .id(self.id)
             .w_96()
@@ -116,10 +115,10 @@ pub struct PaletteItem {
     pub key_binding: Option<KeyBinding>,
 }
 
-impl<V: 'static> Component<V> for PaletteItem {
-    type Rendered = Div<V>;
+impl Component for PaletteItem {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         div()
             .flex()
             .flex_row()
@@ -173,8 +172,8 @@ mod stories {
 
     pub struct PaletteStory;
 
-    impl Render<Self> for PaletteStory {
-        type Element = Div<Self>;
+    impl Render for PaletteStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             {

crates/ui2/src/components/panel.rs

@@ -1,8 +1,8 @@
-use gpui::{prelude::*, AbsoluteLength, AnyElement, Div, RenderOnce, Stateful};
+use gpui::px;
+use gpui::{prelude::*, AbsoluteLength, AnyElement, Div, RenderOnce};
 use smallvec::SmallVec;
 
 use crate::prelude::*;
-use crate::settings::user_settings;
 use crate::v_stack;
 
 #[derive(Default, Debug, PartialEq, Eq, Hash, Clone, Copy)]
@@ -39,20 +39,20 @@ pub enum PanelSide {
 use std::collections::HashSet;
 
 #[derive(RenderOnce)]
-pub struct Panel<V: 'static> {
+pub struct Panel {
     id: ElementId,
     current_side: PanelSide,
     /// Defaults to PanelAllowedSides::LeftAndRight
     allowed_sides: PanelAllowedSides,
     initial_width: AbsoluteLength,
     width: Option<AbsoluteLength>,
-    children: SmallVec<[AnyElement<V>; 2]>,
+    children: SmallVec<[AnyElement; 2]>,
 }
 
-impl<V: 'static> Component<V> for Panel<V> {
-    type Rendered = Stateful<V, Div<V>>;
+impl Component for Panel {
+    type Rendered = gpui::Stateful<Div>;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let current_size = self.width.unwrap_or(self.initial_width);
 
         v_stack()
@@ -73,15 +73,13 @@ impl<V: 'static> Component<V> for Panel<V> {
     }
 }
 
-impl<V: 'static> Panel<V> {
+impl Panel {
     pub fn new(id: impl Into<ElementId>, cx: &mut WindowContext) -> Self {
-        let settings = user_settings(cx);
-
         Self {
             id: id.into(),
             current_side: PanelSide::default(),
             allowed_sides: PanelAllowedSides::default(),
-            initial_width: *settings.default_panel_size,
+            initial_width: px(320.).into(),
             width: None,
             children: SmallVec::new(),
         }
@@ -117,8 +115,8 @@ impl<V: 'static> Panel<V> {
     }
 }
 
-impl<V: 'static> ParentElement<V> for Panel<V> {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
+impl ParentElement for Panel {
+    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
         &mut self.children
     }
 }
@@ -134,12 +132,12 @@ mod stories {
 
     pub struct PanelStory;
 
-    impl Render<Self> for PanelStory {
-        type Element = Div<Self>;
+    impl Render for PanelStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             Story::container(cx)
-                .child(Story::title_for::<_, Panel<Self>>(cx))
+                .child(Story::title_for::<Panel<Self>>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(
                     Panel::new("panel", cx).child(

crates/ui2/src/components/player.rs

@@ -1,4 +1,4 @@
-use gpui::{Hsla, ViewContext};
+use gpui::Hsla;
 
 use crate::prelude::*;
 
@@ -156,11 +156,11 @@ impl Player {
         self
     }
 
-    pub fn cursor_color<V: 'static>(&self, cx: &mut ViewContext<V>) -> Hsla {
+    pub fn cursor_color(&self, cx: &mut WindowContext) -> Hsla {
         cx.theme().styles.player.0[self.index % cx.theme().styles.player.0.len()].cursor
     }
 
-    pub fn selection_color<V: 'static>(&self, cx: &mut ViewContext<V>) -> Hsla {
+    pub fn selection_color(&self, cx: &mut WindowContext) -> Hsla {
         cx.theme().styles.player.0[self.index % cx.theme().styles.player.0.len()].selection
     }
 

crates/ui2/src/components/player_stack.rs

@@ -8,10 +8,10 @@ pub struct PlayerStack {
     player_with_call_status: PlayerWithCallStatus,
 }
 
-impl<V: 'static> Component<V> for PlayerStack {
-    type Rendered = Div<V>;
+impl Component for PlayerStack {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let player = self.player_with_call_status.get_player();
 
         let followers = self

crates/ui2/src/components/stack.rs

@@ -5,13 +5,13 @@ use crate::StyledExt;
 /// Horizontally stacks elements.
 ///
 /// Sets `flex()`, `flex_row()`, `items_center()`
-pub fn h_stack<V: 'static>() -> Div<V> {
+pub fn h_stack() -> Div {
     div().h_flex()
 }
 
 /// Vertically stacks elements.
 ///
 /// Sets `flex()`, `flex_col()`
-pub fn v_stack<V: 'static>() -> Div<V> {
+pub fn v_stack() -> Div {
     div().v_flex()
 }

crates/ui2/src/components/tab.rs

@@ -1,276 +1,276 @@
-use crate::prelude::*;
-use crate::{Icon, IconElement, Label, TextColor};
-use gpui::{prelude::*, red, Div, ElementId, Render, RenderOnce, Stateful, View};
+// use crate::prelude::*;
+// use crate::{Icon, IconElement, Label, TextColor};
+// use gpui::{prelude::*, red, Div, ElementId, Render, RenderOnce, View};
 
-#[derive(RenderOnce, Clone)]
-pub struct Tab {
-    id: ElementId,
-    title: String,
-    icon: Option<Icon>,
-    current: bool,
-    dirty: bool,
-    fs_status: FileSystemStatus,
-    git_status: GitStatus,
-    diagnostic_status: DiagnosticStatus,
-    close_side: IconSide,
-}
+// #[derive(RenderOnce, Clone)]
+// pub struct Tab {
+//     id: ElementId,
+//     title: String,
+//     icon: Option<Icon>,
+//     current: bool,
+//     dirty: bool,
+//     fs_status: FileSystemStatus,
+//     git_status: GitStatus,
+//     diagnostic_status: DiagnosticStatus,
+//     close_side: IconSide,
+// }
 
-#[derive(Clone, Debug)]
-struct TabDragState {
-    title: String,
-}
+// #[derive(Clone, Debug)]
+// struct TabDragState {
+//     title: String,
+// }
 
-impl Render<Self> for TabDragState {
-    type Element = Div<Self>;
+// impl Render for TabDragState {
+//     type Element = Div;
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-        div().w_8().h_4().bg(red())
-    }
-}
+//     fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
+//         div().w_8().h_4().bg(red())
+//     }
+// }
 
-impl<V: 'static> Component<V> for Tab {
-    type Rendered = Stateful<V, Div<V>>;
+// impl Component for Tab {
+//     type Rendered = gpui::Stateful<Div>;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let has_fs_conflict = self.fs_status == FileSystemStatus::Conflict;
-        let is_deleted = self.fs_status == FileSystemStatus::Deleted;
+//     fn render(self, cx: &mut WindowContext) -> Self::Rendered {
+//         let has_fs_conflict = self.fs_status == FileSystemStatus::Conflict;
+//         let is_deleted = self.fs_status == FileSystemStatus::Deleted;
 
-        let label = match (self.git_status, is_deleted) {
-            (_, true) | (GitStatus::Deleted, false) => Label::new(self.title.clone())
-                .color(TextColor::Hidden)
-                .set_strikethrough(true),
-            (GitStatus::None, false) => Label::new(self.title.clone()),
-            (GitStatus::Created, false) => Label::new(self.title.clone()).color(TextColor::Created),
-            (GitStatus::Modified, false) => {
-                Label::new(self.title.clone()).color(TextColor::Modified)
-            }
-            (GitStatus::Renamed, false) => Label::new(self.title.clone()).color(TextColor::Accent),
-            (GitStatus::Conflict, false) => Label::new(self.title.clone()),
-        };
+//         let label = match (self.git_status, is_deleted) {
+//             (_, true) | (GitStatus::Deleted, false) => Label::new(self.title.clone())
+//                 .color(TextColor::Hidden)
+//                 .set_strikethrough(true),
+//             (GitStatus::None, false) => Label::new(self.title.clone()),
+//             (GitStatus::Created, false) => Label::new(self.title.clone()).color(TextColor::Created),
+//             (GitStatus::Modified, false) => {
+//                 Label::new(self.title.clone()).color(TextColor::Modified)
+//             }
+//             (GitStatus::Renamed, false) => Label::new(self.title.clone()).color(TextColor::Accent),
+//             (GitStatus::Conflict, false) => Label::new(self.title.clone()),
+//         };
 
-        let close_icon = || IconElement::new(Icon::Close).color(TextColor::Muted);
+//         let close_icon = || IconElement::new(Icon::Close).color(TextColor::Muted);
 
-        let (tab_bg, tab_hover_bg, tab_active_bg) = match self.current {
-            false => (
-                cx.theme().colors().tab_inactive_background,
-                cx.theme().colors().ghost_element_hover,
-                cx.theme().colors().ghost_element_active,
-            ),
-            true => (
-                cx.theme().colors().tab_active_background,
-                cx.theme().colors().element_hover,
-                cx.theme().colors().element_active,
-            ),
-        };
+//         let (tab_bg, tab_hover_bg, tab_active_bg) = match self.current {
+//             false => (
+//                 cx.theme().colors().tab_inactive_background,
+//                 cx.theme().colors().ghost_element_hover,
+//                 cx.theme().colors().ghost_element_active,
+//             ),
+//             true => (
+//                 cx.theme().colors().tab_active_background,
+//                 cx.theme().colors().element_hover,
+//                 cx.theme().colors().element_active,
+//             ),
+//         };
 
-        let drag_state = TabDragState {
-            title: self.title.clone(),
-        };
+//         let drag_state = TabDragState {
+//             title: self.title.clone(),
+//         };
 
-        div()
-            .id(self.id.clone())
-            .on_drag(move |_view, cx| cx.build_view(|cx| drag_state.clone()))
-            .drag_over::<TabDragState>(|d| d.bg(cx.theme().colors().drop_target_background))
-            .on_drop(|_view, state: View<TabDragState>, cx| {
-                eprintln!("{:?}", state.read(cx));
-            })
-            .px_2()
-            .py_0p5()
-            .flex()
-            .items_center()
-            .justify_center()
-            .bg(tab_bg)
-            .hover(|h| h.bg(tab_hover_bg))
-            .active(|a| a.bg(tab_active_bg))
-            .child(
-                div()
-                    .px_1()
-                    .flex()
-                    .items_center()
-                    .gap_1p5()
-                    .children(has_fs_conflict.then(|| {
-                        IconElement::new(Icon::ExclamationTriangle)
-                            .size(crate::IconSize::Small)
-                            .color(TextColor::Warning)
-                    }))
-                    .children(self.icon.map(IconElement::new))
-                    .children(if self.close_side == IconSide::Left {
-                        Some(close_icon())
-                    } else {
-                        None
-                    })
-                    .child(label)
-                    .children(if self.close_side == IconSide::Right {
-                        Some(close_icon())
-                    } else {
-                        None
-                    }),
-            )
-    }
-}
+//         div()
+//             .id(self.id.clone())
+//             .on_drag(move |_view, cx| cx.build_view(|cx| drag_state.clone()))
+//             .drag_over::<TabDragState>(|d| d.bg(cx.theme().colors().drop_target_background))
+//             .on_drop(|_view, state: View<TabDragState>, cx| {
+//                 eprintln!("{:?}", state.read(cx));
+//             })
+//             .px_2()
+//             .py_0p5()
+//             .flex()
+//             .items_center()
+//             .justify_center()
+//             .bg(tab_bg)
+//             .hover(|h| h.bg(tab_hover_bg))
+//             .active(|a| a.bg(tab_active_bg))
+//             .child(
+//                 div()
+//                     .px_1()
+//                     .flex()
+//                     .items_center()
+//                     .gap_1p5()
+//                     .children(has_fs_conflict.then(|| {
+//                         IconElement::new(Icon::ExclamationTriangle)
+//                             .size(crate::IconSize::Small)
+//                             .color(TextColor::Warning)
+//                     }))
+//                     .children(self.icon.map(IconElement::new))
+//                     .children(if self.close_side == IconSide::Left {
+//                         Some(close_icon())
+//                     } else {
+//                         None
+//                     })
+//                     .child(label)
+//                     .children(if self.close_side == IconSide::Right {
+//                         Some(close_icon())
+//                     } else {
+//                         None
+//                     }),
+//             )
+//     }
+// }
 
-impl Tab {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            title: "untitled".to_string(),
-            icon: None,
-            current: false,
-            dirty: false,
-            fs_status: FileSystemStatus::None,
-            git_status: GitStatus::None,
-            diagnostic_status: DiagnosticStatus::None,
-            close_side: IconSide::Right,
-        }
-    }
+// impl Tab {
+//     pub fn new(id: impl Into<ElementId>) -> Self {
+//         Self {
+//             id: id.into(),
+//             title: "untitled".to_string(),
+//             icon: None,
+//             current: false,
+//             dirty: false,
+//             fs_status: FileSystemStatus::None,
+//             git_status: GitStatus::None,
+//             diagnostic_status: DiagnosticStatus::None,
+//             close_side: IconSide::Right,
+//         }
+//     }
 
-    pub fn current(mut self, current: bool) -> Self {
-        self.current = current;
-        self
-    }
+//     pub fn current(mut self, current: bool) -> Self {
+//         self.current = current;
+//         self
+//     }
 
-    pub fn title(mut self, title: String) -> Self {
-        self.title = title;
-        self
-    }
+//     pub fn title(mut self, title: String) -> Self {
+//         self.title = title;
+//         self
+//     }
 
-    pub fn icon<I>(mut self, icon: I) -> Self
-    where
-        I: Into<Option<Icon>>,
-    {
-        self.icon = icon.into();
-        self
-    }
+//     pub fn icon<I>(mut self, icon: I) -> Self
+//     where
+//         I: Into<Option<Icon>>,
+//     {
+//         self.icon = icon.into();
+//         self
+//     }
 
-    pub fn dirty(mut self, dirty: bool) -> Self {
-        self.dirty = dirty;
-        self
-    }
+//     pub fn dirty(mut self, dirty: bool) -> Self {
+//         self.dirty = dirty;
+//         self
+//     }
 
-    pub fn fs_status(mut self, fs_status: FileSystemStatus) -> Self {
-        self.fs_status = fs_status;
-        self
-    }
+//     pub fn fs_status(mut self, fs_status: FileSystemStatus) -> Self {
+//         self.fs_status = fs_status;
+//         self
+//     }
 
-    pub fn git_status(mut self, git_status: GitStatus) -> Self {
-        self.git_status = git_status;
-        self
-    }
+//     pub fn git_status(mut self, git_status: GitStatus) -> Self {
+//         self.git_status = git_status;
+//         self
+//     }
 
-    pub fn diagnostic_status(mut self, diagnostic_status: DiagnosticStatus) -> Self {
-        self.diagnostic_status = diagnostic_status;
-        self
-    }
+//     pub fn diagnostic_status(mut self, diagnostic_status: DiagnosticStatus) -> Self {
+//         self.diagnostic_status = diagnostic_status;
+//         self
+//     }
 
-    pub fn close_side(mut self, close_side: IconSide) -> Self {
-        self.close_side = close_side;
-        self
-    }
-}
+//     pub fn close_side(mut self, close_side: IconSide) -> Self {
+//         self.close_side = close_side;
+//         self
+//     }
+// }
 
-#[cfg(feature = "stories")]
-pub use stories::*;
+// #[cfg(feature = "stories")]
+// pub use stories::*;
 
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::{h_stack, v_stack, Icon, Story};
-    use strum::IntoEnumIterator;
+// #[cfg(feature = "stories")]
+// mod stories {
+//     use super::*;
+//     use crate::{h_stack, v_stack, Icon, Story};
+//     use strum::IntoEnumIterator;
 
-    pub struct TabStory;
+//     pub struct TabStory;
 
-    impl Render<Self> for TabStory {
-        type Element = Div<Self>;
+//     impl Render for TabStory {
+//         type Element = Div;
 
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            let git_statuses = GitStatus::iter();
-            let fs_statuses = FileSystemStatus::iter();
+//         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
+//             let git_statuses = GitStatus::iter();
+//             let fs_statuses = FileSystemStatus::iter();
 
-            Story::container(cx)
-                .child(Story::title_for::<_, Tab>(cx))
-                .child(
-                    h_stack().child(
-                        v_stack()
-                            .gap_2()
-                            .child(Story::label(cx, "Default"))
-                            .child(Tab::new("default")),
-                    ),
-                )
-                .child(
-                    h_stack().child(
-                        v_stack().gap_2().child(Story::label(cx, "Current")).child(
-                            h_stack()
-                                .gap_4()
-                                .child(
-                                    Tab::new("current")
-                                        .title("Current".to_string())
-                                        .current(true),
-                                )
-                                .child(
-                                    Tab::new("not_current")
-                                        .title("Not Current".to_string())
-                                        .current(false),
-                                ),
-                        ),
-                    ),
-                )
-                .child(
-                    h_stack().child(
-                        v_stack()
-                            .gap_2()
-                            .child(Story::label(cx, "Titled"))
-                            .child(Tab::new("titled").title("label".to_string())),
-                    ),
-                )
-                .child(
-                    h_stack().child(
-                        v_stack()
-                            .gap_2()
-                            .child(Story::label(cx, "With Icon"))
-                            .child(
-                                Tab::new("with_icon")
-                                    .title("label".to_string())
-                                    .icon(Some(Icon::Envelope)),
-                            ),
-                    ),
-                )
-                .child(
-                    h_stack().child(
-                        v_stack()
-                            .gap_2()
-                            .child(Story::label(cx, "Close Side"))
-                            .child(
-                                h_stack()
-                                    .gap_4()
-                                    .child(
-                                        Tab::new("left")
-                                            .title("Left".to_string())
-                                            .close_side(IconSide::Left),
-                                    )
-                                    .child(Tab::new("right").title("Right".to_string())),
-                            ),
-                    ),
-                )
-                .child(
-                    v_stack()
-                        .gap_2()
-                        .child(Story::label(cx, "Git Status"))
-                        .child(h_stack().gap_4().children(git_statuses.map(|git_status| {
-                            Tab::new("git_status")
-                                .title(git_status.to_string())
-                                .git_status(git_status)
-                        }))),
-                )
-                .child(
-                    v_stack()
-                        .gap_2()
-                        .child(Story::label(cx, "File System Status"))
-                        .child(h_stack().gap_4().children(fs_statuses.map(|fs_status| {
-                            Tab::new("file_system_status")
-                                .title(fs_status.to_string())
-                                .fs_status(fs_status)
-                        }))),
-                )
-        }
-    }
-}
+//             Story::container(cx)
+//                 .child(Story::title_for::<_, Tab>(cx))
+//                 .child(
+//                     h_stack().child(
+//                         v_stack()
+//                             .gap_2()
+//                             .child(Story::label(cx, "Default"))
+//                             .child(Tab::new("default")),
+//                     ),
+//                 )
+//                 .child(
+//                     h_stack().child(
+//                         v_stack().gap_2().child(Story::label(cx, "Current")).child(
+//                             h_stack()
+//                                 .gap_4()
+//                                 .child(
+//                                     Tab::new("current")
+//                                         .title("Current".to_string())
+//                                         .current(true),
+//                                 )
+//                                 .child(
+//                                     Tab::new("not_current")
+//                                         .title("Not Current".to_string())
+//                                         .current(false),
+//                                 ),
+//                         ),
+//                     ),
+//                 )
+//                 .child(
+//                     h_stack().child(
+//                         v_stack()
+//                             .gap_2()
+//                             .child(Story::label(cx, "Titled"))
+//                             .child(Tab::new("titled").title("label".to_string())),
+//                     ),
+//                 )
+//                 .child(
+//                     h_stack().child(
+//                         v_stack()
+//                             .gap_2()
+//                             .child(Story::label(cx, "With Icon"))
+//                             .child(
+//                                 Tab::new("with_icon")
+//                                     .title("label".to_string())
+//                                     .icon(Some(Icon::Envelope)),
+//                             ),
+//                     ),
+//                 )
+//                 .child(
+//                     h_stack().child(
+//                         v_stack()
+//                             .gap_2()
+//                             .child(Story::label(cx, "Close Side"))
+//                             .child(
+//                                 h_stack()
+//                                     .gap_4()
+//                                     .child(
+//                                         Tab::new("left")
+//                                             .title("Left".to_string())
+//                                             .close_side(IconSide::Left),
+//                                     )
+//                                     .child(Tab::new("right").title("Right".to_string())),
+//                             ),
+//                     ),
+//                 )
+//                 .child(
+//                     v_stack()
+//                         .gap_2()
+//                         .child(Story::label(cx, "Git Status"))
+//                         .child(h_stack().gap_4().children(git_statuses.map(|git_status| {
+//                             Tab::new("git_status")
+//                                 .title(git_status.to_string())
+//                                 .git_status(git_status)
+//                         }))),
+//                 )
+//                 .child(
+//                     v_stack()
+//                         .gap_2()
+//                         .child(Story::label(cx, "File System Status"))
+//                         .child(h_stack().gap_4().children(fs_statuses.map(|fs_status| {
+//                             Tab::new("file_system_status")
+//                                 .title(fs_status.to_string())
+//                                 .fs_status(fs_status)
+//                         }))),
+//                 )
+//         }
+//     }
+// }

crates/ui2/src/components/toast.rs

@@ -23,15 +23,15 @@ pub enum ToastOrigin {
 ///
 /// Only one toast may be visible at a time.
 #[derive(RenderOnce)]
-pub struct Toast<V: 'static> {
+pub struct Toast {
     origin: ToastOrigin,
-    children: SmallVec<[AnyElement<V>; 2]>,
+    children: SmallVec<[AnyElement; 2]>,
 }
 
-impl<V: 'static> Component<V> for Toast<V> {
-    type Rendered = Div<V>;
+impl Component for Toast {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         let mut div = div();
 
         if self.origin == ToastOrigin::Bottom {
@@ -54,7 +54,7 @@ impl<V: 'static> Component<V> for Toast<V> {
     }
 }
 
-impl<V: 'static> Toast<V> {
+impl Toast {
     pub fn new(origin: ToastOrigin) -> Self {
         Self {
             origin,
@@ -62,7 +62,7 @@ impl<V: 'static> Toast<V> {
         }
     }
 
-    fn render(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+    fn render(self, cx: &mut WindowContext) -> impl Element {
         let mut div = div();
 
         if self.origin == ToastOrigin::Bottom {
@@ -85,8 +85,8 @@ impl<V: 'static> Toast<V> {
     }
 }
 
-impl<V: 'static> ParentElement<V> for Toast<V> {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
+impl ParentElement for Toast {
+    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
         &mut self.children
     }
 }
@@ -104,12 +104,12 @@ mod stories {
 
     pub struct ToastStory;
 
-    impl Render<Self> for ToastStory {
-        type Element = Div<Self>;
+    impl Render for ToastStory {
+        type Element = Div;
 
         fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
             Story::container(cx)
-                .child(Story::title_for::<_, Toast<Self>>(cx))
+                .child(Story::title_for::<Toast<Self>>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(Toast::new(ToastOrigin::Bottom).child(Label::new("label")))
         }

crates/ui2/src/components/toggle.rs

@@ -44,7 +44,7 @@ impl From<bool> for Toggle {
     }
 }
 
-pub fn disclosure_control<V: 'static>(toggle: Toggle) -> impl Element<V> {
+pub fn disclosure_control(toggle: Toggle) -> impl Element {
     match (toggle.is_toggleable(), toggle.is_toggled()) {
         (false, _) => div(),
         (_, true) => div().child(

crates/ui2/src/components/tool_divider.rs

@@ -4,10 +4,10 @@ use gpui::{Div, RenderOnce};
 #[derive(RenderOnce)]
 pub struct ToolDivider;
 
-impl<V: 'static> Component<V> for ToolDivider {
-    type Rendered = Div<V>;
+impl Component for ToolDivider {
+    type Rendered = Div;
 
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
+    fn render(self, cx: &mut WindowContext) -> Self::Rendered {
         div().w_px().h_3().bg(cx.theme().colors().border)
     }
 }
@@ -17,7 +17,7 @@ impl ToolDivider {
         Self
     }
 
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
+    fn render(self, cx: &mut WindowContext) -> impl Element {
         div().w_px().h_3().bg(cx.theme().colors().border)
     }
 }

crates/ui2/src/components/tooltip.rs

@@ -67,8 +67,8 @@ impl Tooltip {
     }
 }
 
-impl Render<Self> for Tooltip {
-    type Element = Overlay<Self>;
+impl Render for Tooltip {
+    type Element = Overlay;
 
     fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
         let ui_font = ThemeSettings::get_global(cx).ui_font.family.clone();

crates/ui2/src/lib.rs

@@ -17,34 +17,15 @@
 mod components;
 mod elevation;
 pub mod prelude;
-pub mod settings;
-mod static_data;
 mod styled_ext;
-mod to_extract;
 pub mod utils;
 
 pub use components::*;
-use gpui::actions;
 pub use prelude::*;
-pub use static_data::*;
+// pub use static_data::*;
 pub use styled_ext::*;
-pub use to_extract::*;
-
-// This needs to be fully qualified with `crate::` otherwise we get a panic
-// at:
-//   thread '<unnamed>' panicked at crates/gpui2/src/platform/mac/platform.rs:66:81:
-//   called `Option::unwrap()` on a `None` value
-//
-// AFAICT this is something to do with conflicting names between crates and modules that
-// interfaces with declaring the `ClassDecl`.
-pub use crate::settings::*;
 
 #[cfg(feature = "stories")]
 mod story;
 #[cfg(feature = "stories")]
 pub use story::*;
-actions!(NoAction);
-
-pub fn binding(key: &str) -> gpui::KeyBinding {
-    gpui::KeyBinding::new(key, NoAction {}, None)
-}

crates/ui2/src/settings.rs

@@ -1,74 +0,0 @@
-use std::ops::Deref;
-
-use gpui::{rems, AbsoluteLength, AppContext, WindowContext};
-
-use crate::prelude::*;
-
-pub fn init(cx: &mut AppContext) {
-    cx.set_global(FakeSettings::default());
-}
-
-/// Returns the user settings.
-pub fn user_settings(cx: &WindowContext) -> FakeSettings {
-    cx.global::<FakeSettings>().clone()
-}
-
-pub fn user_settings_mut<'cx>(cx: &'cx mut WindowContext) -> &'cx mut FakeSettings {
-    cx.global_mut::<FakeSettings>()
-}
-
-#[derive(Clone)]
-pub enum SettingValue<T> {
-    UserDefined(T),
-    Default(T),
-}
-
-impl<T> Deref for SettingValue<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            Self::UserDefined(value) => value,
-            Self::Default(value) => value,
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct TitlebarSettings {
-    pub show_project_owner: SettingValue<bool>,
-    pub show_git_status: SettingValue<bool>,
-    pub show_git_controls: SettingValue<bool>,
-}
-
-impl Default for TitlebarSettings {
-    fn default() -> Self {
-        Self {
-            show_project_owner: SettingValue::Default(true),
-            show_git_status: SettingValue::Default(true),
-            show_git_controls: SettingValue::Default(true),
-        }
-    }
-}
-
-// These should be merged into settings
-#[derive(Clone)]
-pub struct FakeSettings {
-    pub default_panel_size: SettingValue<AbsoluteLength>,
-    pub list_disclosure_style: SettingValue<DisclosureControlStyle>,
-    pub list_indent_depth: SettingValue<AbsoluteLength>,
-    pub titlebar: TitlebarSettings,
-}
-
-impl Default for FakeSettings {
-    fn default() -> Self {
-        Self {
-            titlebar: TitlebarSettings::default(),
-            list_disclosure_style: SettingValue::Default(DisclosureControlStyle::ChevronOnHover),
-            list_indent_depth: SettingValue::Default(rems(0.3).into()),
-            default_panel_size: SettingValue::Default(rems(16.).into()),
-        }
-    }
-}
-
-impl FakeSettings {}

crates/ui2/src/story.rs

@@ -5,7 +5,7 @@ use crate::prelude::*;
 pub struct Story {}
 
 impl Story {
-    pub fn container<V: 'static>(cx: &mut ViewContext<V>) -> Div<V> {
+    pub fn container(cx: &mut gpui::WindowContext) -> Div {
         div()
             .size_full()
             .flex()
@@ -16,23 +16,23 @@ impl Story {
     }
 
     pub fn title<V: 'static>(
-        cx: &mut ViewContext<V>,
+        cx: &mut WindowContext,
         title: impl Into<SharedString>,
-    ) -> impl Element<V> {
+    ) -> impl Element {
         div()
             .text_xl()
             .text_color(cx.theme().colors().text)
             .child(title.into())
     }
 
-    pub fn title_for<V: 'static, T>(cx: &mut ViewContext<V>) -> impl Element<V> {
+    pub fn title_for<T>(cx: &mut WindowContext) -> impl Element {
         Self::title(cx, std::any::type_name::<T>())
     }
 
     pub fn label<V: 'static>(
-        cx: &mut ViewContext<V>,
+        cx: &mut WindowContext,
         label: impl Into<SharedString>,
-    ) -> impl Element<V> {
+    ) -> impl Element {
         div()
             .mt_4()
             .mb_2()

crates/ui2/src/styled_ext.rs

@@ -1,9 +1,9 @@
-use gpui::{Styled, ViewContext};
+use gpui::{Styled, WindowContext};
 use theme2::ActiveTheme;
 
 use crate::{ElevationIndex, UITextSize};
 
-fn elevated<E: Styled, V: 'static>(this: E, cx: &mut ViewContext<V>, index: ElevationIndex) -> E {
+fn elevated<E: Styled>(this: E, cx: &mut WindowContext, index: ElevationIndex) -> E {
     this.bg(cx.theme().colors().elevated_surface_background)
         .z_index(index.z_index())
         .rounded_lg()
@@ -65,7 +65,7 @@ pub trait StyledExt: Styled + Sized {
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
     /// Example Elements: Title Bar, Panel, Tab Bar, Editor
-    fn elevation_1<V: 'static>(self, cx: &mut ViewContext<V>) -> Self {
+    fn elevation_1(self, cx: &mut WindowContext) -> Self {
         elevated(self, cx, ElevationIndex::Surface)
     }
 
@@ -74,7 +74,7 @@ pub trait StyledExt: Styled + Sized {
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
     /// Examples: Notifications, Palettes, Detached/Floating Windows, Detached/Floating Panels
-    fn elevation_2<V: 'static>(self, cx: &mut ViewContext<V>) -> Self {
+    fn elevation_2(self, cx: &mut WindowContext) -> Self {
         elevated(self, cx, ElevationIndex::ElevatedSurface)
     }
 
@@ -89,7 +89,7 @@ pub trait StyledExt: Styled + Sized {
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
     /// Examples: Settings Modal, Channel Management, Wizards/Setup UI, Dialogs
-    fn elevation_4<V: 'static>(self, cx: &mut ViewContext<V>) -> Self {
+    fn elevation_4(self, cx: &mut WindowContext) -> Self {
         elevated(self, cx, ElevationIndex::ModalSurface)
     }
 }

crates/ui2/src/to_extract.rs

@@ -1,47 +0,0 @@
-mod assistant_panel;
-mod breadcrumb;
-mod buffer;
-mod buffer_search;
-mod chat_panel;
-mod collab_panel;
-mod command_palette;
-mod copilot;
-mod editor_pane;
-mod language_selector;
-mod multi_buffer;
-mod notifications_panel;
-mod panes;
-mod project_panel;
-mod recent_projects;
-mod status_bar;
-mod tab_bar;
-mod terminal;
-mod theme_selector;
-mod title_bar;
-mod toolbar;
-mod traffic_lights;
-mod workspace;
-
-pub use assistant_panel::*;
-pub use breadcrumb::*;
-pub use buffer::*;
-pub use buffer_search::*;
-pub use chat_panel::*;
-pub use collab_panel::*;
-pub use command_palette::*;
-pub use copilot::*;
-pub use editor_pane::*;
-pub use language_selector::*;
-pub use multi_buffer::*;
-pub use notifications_panel::*;
-pub use panes::*;
-pub use project_panel::*;
-pub use recent_projects::*;
-pub use status_bar::*;
-pub use tab_bar::*;
-pub use terminal::*;
-pub use theme_selector::*;
-pub use title_bar::*;
-pub use toolbar::*;
-pub use traffic_lights::*;
-pub use workspace::*;

crates/ui2/src/to_extract/assistant_panel.rs

@@ -1,97 +0,0 @@
-use crate::prelude::*;
-use crate::{Icon, IconButton, Label, Panel, PanelSide};
-use gpui::{prelude::*, rems, AbsoluteLength, RenderOnce};
-
-#[derive(RenderOnce)]
-pub struct AssistantPanel {
-    id: ElementId,
-    current_side: PanelSide,
-}
-
-impl<V: 'static> Component<V> for AssistantPanel {
-    type Rendered = Panel<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        Panel::new(self.id.clone(), cx)
-            .children(vec![div()
-                .flex()
-                .flex_col()
-                .h_full()
-                .px_2()
-                .gap_2()
-                // Header
-                .child(
-                    div()
-                        .flex()
-                        .justify_between()
-                        .gap_2()
-                        .child(
-                            div()
-                                .flex()
-                                .child(IconButton::new("menu", Icon::Menu))
-                                .child(Label::new("New Conversation")),
-                        )
-                        .child(
-                            div()
-                                .flex()
-                                .items_center()
-                                .gap_px()
-                                .child(IconButton::new("split_message", Icon::SplitMessage))
-                                .child(IconButton::new("quote", Icon::Quote))
-                                .child(IconButton::new("magic_wand", Icon::MagicWand))
-                                .child(IconButton::new("plus", Icon::Plus))
-                                .child(IconButton::new("maximize", Icon::Maximize)),
-                        ),
-                )
-                // Chat Body
-                .child(
-                    div()
-                        .id("chat-body")
-                        .w_full()
-                        .flex()
-                        .flex_col()
-                        .gap_3()
-                        .overflow_y_scroll()
-                        .child(Label::new("Is this thing on?")),
-                )
-                .into_any()])
-            .side(self.current_side)
-            .width(AbsoluteLength::Rems(rems(32.)))
-    }
-}
-
-impl AssistantPanel {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            current_side: PanelSide::default(),
-        }
-    }
-
-    pub fn side(mut self, side: PanelSide) -> Self {
-        self.current_side = side;
-        self
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-    use gpui::{Div, Render};
-    pub struct AssistantPanelStory;
-
-    impl Render<Self> for AssistantPanelStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, AssistantPanel>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(AssistantPanel::new("assistant-panel"))
-        }
-    }
-}

crates/ui2/src/to_extract/breadcrumb.rs

@@ -1,118 +0,0 @@
-use crate::{h_stack, prelude::*, HighlightedText};
-use gpui::{prelude::*, Div, Stateful};
-use std::path::PathBuf;
-
-#[derive(Clone)]
-pub struct Symbol(pub Vec<HighlightedText>);
-
-#[derive(RenderOnce)]
-pub struct Breadcrumb {
-    path: PathBuf,
-    symbols: Vec<Symbol>,
-}
-
-impl<V: 'static> Component<V> for Breadcrumb {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view_state: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let symbols_len = self.symbols.len();
-        h_stack()
-            .id("breadcrumb")
-            .px_1()
-            .text_ui_sm()
-            .text_color(cx.theme().colors().text_muted)
-            .rounded_md()
-            .hover(|style| style.bg(cx.theme().colors().ghost_element_hover))
-            .active(|style| style.bg(cx.theme().colors().ghost_element_active))
-            .child(SharedString::from(
-                self.path.clone().to_str().unwrap().to_string(),
-            ))
-            .child(if !self.symbols.is_empty() {
-                self.render_separator(cx)
-            } else {
-                div()
-            })
-            .child(
-                div().flex().children(
-                    self.symbols
-                        .iter()
-                        .enumerate()
-                        // TODO: Could use something like `intersperse` here instead.
-                        .flat_map(|(ix, symbol)| {
-                            let mut items =
-                                vec![div().flex().children(symbol.0.iter().map(|segment| {
-                                    div().child(segment.text.clone()).text_color(segment.color)
-                                }))];
-
-                            let is_last_segment = ix == symbols_len - 1;
-                            if !is_last_segment {
-                                items.push(self.render_separator(cx));
-                            }
-
-                            items
-                        })
-                        .collect::<Vec<_>>(),
-                ),
-            )
-    }
-}
-
-impl Breadcrumb {
-    pub fn new(path: PathBuf, symbols: Vec<Symbol>) -> Self {
-        Self { path, symbols }
-    }
-
-    fn render_separator<V: 'static>(&self, cx: &WindowContext) -> Div<V> {
-        div()
-            .child(" › ")
-            .text_color(cx.theme().colors().text_muted)
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-    use gpui::Render;
-    use std::str::FromStr;
-
-    pub struct BreadcrumbStory;
-
-    impl Render<Self> for BreadcrumbStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(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(),
-                    vec![
-                        Symbol(vec![
-                            HighlightedText {
-                                text: "impl ".into(),
-                                color: cx.theme().syntax_color("keyword"),
-                            },
-                            HighlightedText {
-                                text: "BreadcrumbStory".into(),
-                                color: cx.theme().syntax_color("function"),
-                            },
-                        ]),
-                        Symbol(vec![
-                            HighlightedText {
-                                text: "fn ".into(),
-                                color: cx.theme().syntax_color("keyword"),
-                            },
-                            HighlightedText {
-                                text: "render".into(),
-                                color: cx.theme().syntax_color("function"),
-                            },
-                        ]),
-                    ],
-                ))
-        }
-    }
-}

crates/ui2/src/to_extract/buffer.rs

@@ -1,281 +0,0 @@
-use gpui::{Div, Hsla, RenderOnce, WindowContext};
-
-use crate::prelude::*;
-use crate::{h_stack, v_stack, Icon, IconElement};
-
-#[derive(Default, PartialEq, Copy, Clone)]
-pub struct PlayerCursor {
-    color: Hsla,
-    index: usize,
-}
-
-#[derive(Default, PartialEq, Clone)]
-pub struct HighlightedText {
-    pub text: SharedString,
-    pub color: Hsla,
-}
-
-#[derive(Default, PartialEq, Clone)]
-pub struct HighlightedLine {
-    pub highlighted_texts: Vec<HighlightedText>,
-}
-
-#[derive(Default, PartialEq, Clone)]
-pub struct BufferRow {
-    pub line_number: usize,
-    pub code_action: bool,
-    pub current: bool,
-    pub line: Option<HighlightedLine>,
-    pub cursors: Option<Vec<PlayerCursor>>,
-    pub status: GitStatus,
-    pub show_line_number: bool,
-}
-
-#[derive(Clone)]
-pub struct BufferRows {
-    pub show_line_numbers: bool,
-    pub rows: Vec<BufferRow>,
-}
-
-impl Default for BufferRows {
-    fn default() -> Self {
-        Self {
-            show_line_numbers: true,
-            rows: vec![BufferRow {
-                line_number: 1,
-                code_action: false,
-                current: true,
-                line: None,
-                cursors: None,
-                status: GitStatus::None,
-                show_line_number: true,
-            }],
-        }
-    }
-}
-
-impl BufferRow {
-    pub fn new(line_number: usize) -> Self {
-        Self {
-            line_number,
-            code_action: false,
-            current: false,
-            line: None,
-            cursors: None,
-            status: GitStatus::None,
-            show_line_number: true,
-        }
-    }
-
-    pub fn set_line(mut self, line: Option<HighlightedLine>) -> Self {
-        self.line = line;
-        self
-    }
-
-    pub fn set_cursors(mut self, cursors: Option<Vec<PlayerCursor>>) -> Self {
-        self.cursors = cursors;
-        self
-    }
-
-    pub fn add_cursor(mut self, cursor: PlayerCursor) -> Self {
-        if let Some(cursors) = &mut self.cursors {
-            cursors.push(cursor);
-        } else {
-            self.cursors = Some(vec![cursor]);
-        }
-        self
-    }
-
-    pub fn set_status(mut self, status: GitStatus) -> Self {
-        self.status = status;
-        self
-    }
-
-    pub fn set_show_line_number(mut self, show_line_number: bool) -> Self {
-        self.show_line_number = show_line_number;
-        self
-    }
-
-    pub fn set_code_action(mut self, code_action: bool) -> Self {
-        self.code_action = code_action;
-        self
-    }
-
-    pub fn set_current(mut self, current: bool) -> Self {
-        self.current = current;
-        self
-    }
-}
-
-#[derive(RenderOnce, Clone)]
-pub struct Buffer {
-    id: ElementId,
-    rows: Option<BufferRows>,
-    readonly: bool,
-    language: Option<String>,
-    title: Option<String>,
-    path: Option<String>,
-}
-
-impl<V: 'static> Component<V> for Buffer {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let rows = self.render_rows(cx);
-
-        v_stack()
-            .flex_1()
-            .w_full()
-            .h_full()
-            .bg(cx.theme().colors().editor_background)
-            .children(rows)
-    }
-}
-
-impl Buffer {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            rows: Some(BufferRows::default()),
-            readonly: false,
-            language: None,
-            title: Some("untitled".to_string()),
-            path: None,
-        }
-    }
-
-    pub fn set_title<T: Into<Option<String>>>(mut self, title: T) -> Self {
-        self.title = title.into();
-        self
-    }
-
-    pub fn set_path<P: Into<Option<String>>>(mut self, path: P) -> Self {
-        self.path = path.into();
-        self
-    }
-
-    pub fn set_readonly(mut self, readonly: bool) -> Self {
-        self.readonly = readonly;
-        self
-    }
-
-    pub fn set_rows<R: Into<Option<BufferRows>>>(mut self, rows: R) -> Self {
-        self.rows = rows.into();
-        self
-    }
-
-    pub fn set_language<L: Into<Option<String>>>(mut self, language: L) -> Self {
-        self.language = language.into();
-        self
-    }
-
-    fn render_row<V: 'static>(row: BufferRow, cx: &WindowContext) -> impl Element<V> {
-        let line_background = if row.current {
-            cx.theme().colors().editor_active_line_background
-        } else {
-            cx.theme().styles.system.transparent
-        };
-
-        let line_number_color = if row.current {
-            cx.theme().colors().text
-        } else {
-            cx.theme().syntax_color("comment")
-        };
-
-        h_stack()
-            .bg(line_background)
-            .w_full()
-            .gap_2()
-            .px_1()
-            .child(
-                h_stack()
-                    .w_4()
-                    .h_full()
-                    .px_0p5()
-                    .when(row.code_action, |c| {
-                        div().child(IconElement::new(Icon::Bolt))
-                    }),
-            )
-            .when(row.show_line_number, |this| {
-                this.child(
-                    h_stack().justify_end().px_0p5().w_3().child(
-                        div()
-                            .text_color(line_number_color)
-                            .child(SharedString::from(row.line_number.to_string())),
-                    ),
-                )
-            })
-            .child(div().mx_0p5().w_1().h_full().bg(row.status.hsla(cx)))
-            .children(row.line.map(|line| {
-                div()
-                    .flex()
-                    .children(line.highlighted_texts.iter().map(|highlighted_text| {
-                        div()
-                            .text_color(highlighted_text.color)
-                            .child(highlighted_text.text.clone())
-                    }))
-            }))
-    }
-
-    fn render_rows<V: 'static>(&self, cx: &WindowContext) -> Vec<impl Element<V>> {
-        match &self.rows {
-            Some(rows) => rows
-                .rows
-                .iter()
-                .map(|row| Self::render_row(row.clone(), cx))
-                .collect(),
-            None => vec![],
-        }
-    }
-
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
-        let rows = self.render_rows(cx);
-
-        v_stack()
-            .flex_1()
-            .w_full()
-            .h_full()
-            .bg(cx.theme().colors().editor_background)
-            .children(rows)
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::{
-        empty_buffer_example, hello_world_rust_buffer_example,
-        hello_world_rust_buffer_with_status_example, Story,
-    };
-    use gpui::{rems, Div, Render};
-
-    pub struct BufferStory;
-
-    impl Render<Self> for BufferStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(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)"))
-                .child(
-                    div()
-                        .w(rems(64.))
-                        .h_96()
-                        .child(hello_world_rust_buffer_example(cx)),
-                )
-                .child(Story::label(cx, "Hello World (Rust) with Status"))
-                .child(
-                    div()
-                        .w(rems(64.))
-                        .h_96()
-                        .child(hello_world_rust_buffer_with_status_example(cx)),
-                )
-        }
-    }
-}

crates/ui2/src/to_extract/buffer_search.rs

@@ -1,45 +0,0 @@
-use crate::prelude::*;
-use crate::{h_stack, Icon, IconButton, Input, TextColor};
-use gpui::{Div, Render, RenderOnce, View, VisualContext};
-
-#[derive(Clone)]
-pub struct BufferSearch {
-    is_replace_open: bool,
-}
-
-impl BufferSearch {
-    pub fn new() -> Self {
-        Self {
-            is_replace_open: false,
-        }
-    }
-
-    fn toggle_replace(&mut self, cx: &mut ViewContext<Self>) {
-        self.is_replace_open = !self.is_replace_open;
-
-        cx.notify();
-    }
-
-    pub fn view(cx: &mut WindowContext) -> View<Self> {
-        cx.build_view(|cx| Self::new())
-    }
-}
-
-impl Render<Self> for BufferSearch {
-    type Element = Div<Self>;
-
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Div<Self> {
-        h_stack()
-            .bg(cx.theme().colors().toolbar_background)
-            .p_2()
-            .child(
-                h_stack().child(Input::new("Search")).child(
-                    IconButton::<Self>::new("replace", Icon::Replace)
-                        .when(self.is_replace_open, |this| this.color(TextColor::Accent))
-                        .on_click(|buffer_search, cx| {
-                            buffer_search.toggle_replace(cx);
-                        }),
-                ),
-            )
-    }
-}

crates/ui2/src/to_extract/chat_panel.rs

@@ -1,158 +0,0 @@
-use crate::{prelude::*, Icon, IconButton, Input, Label};
-use chrono::NaiveDateTime;
-use gpui::{prelude::*, Div, Stateful};
-
-#[derive(RenderOnce)]
-pub struct ChatPanel {
-    element_id: ElementId,
-    messages: Vec<ChatMessage>,
-}
-
-impl<V: 'static> Component<V> for ChatPanel {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div()
-            .id(self.element_id.clone())
-            .flex()
-            .flex_col()
-            .justify_between()
-            .h_full()
-            .px_2()
-            .gap_2()
-            // Header
-            .child(
-                div()
-                    .flex()
-                    .justify_between()
-                    .py_2()
-                    .child(div().flex().child(Label::new("#design")))
-                    .child(
-                        div()
-                            .flex()
-                            .items_center()
-                            .gap_px()
-                            .child(IconButton::new("file", Icon::File))
-                            .child(IconButton::new("audio_on", Icon::AudioOn)),
-                    ),
-            )
-            .child(
-                div()
-                    .flex()
-                    .flex_col()
-                    // Chat Body
-                    .child(
-                        div()
-                            .id("chat-body")
-                            .w_full()
-                            .flex()
-                            .flex_col()
-                            .gap_3()
-                            .overflow_y_scroll()
-                            .children(self.messages),
-                    )
-                    // Composer
-                    .child(div().flex().my_2().child(Input::new("Message #design"))),
-            )
-    }
-}
-
-impl ChatPanel {
-    pub fn new(element_id: impl Into<ElementId>) -> Self {
-        Self {
-            element_id: element_id.into(),
-            messages: Vec::new(),
-        }
-    }
-
-    pub fn messages(mut self, messages: Vec<ChatMessage>) -> Self {
-        self.messages = messages;
-        self
-    }
-}
-
-#[derive(RenderOnce)]
-pub struct ChatMessage {
-    author: String,
-    text: String,
-    sent_at: NaiveDateTime,
-}
-
-impl<V: 'static> Component<V> for ChatMessage {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div()
-            .flex()
-            .flex_col()
-            .child(
-                div()
-                    .flex()
-                    .gap_2()
-                    .child(Label::new(self.author.clone()))
-                    .child(
-                        Label::new(self.sent_at.format("%m/%d/%Y").to_string())
-                            .color(TextColor::Muted),
-                    ),
-            )
-            .child(div().child(Label::new(self.text.clone())))
-    }
-}
-
-impl ChatMessage {
-    pub fn new(author: String, text: String, sent_at: NaiveDateTime) -> Self {
-        Self {
-            author,
-            text,
-            sent_at,
-        }
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use chrono::DateTime;
-    use gpui::{Div, Render};
-
-    use crate::{Panel, Story};
-
-    use super::*;
-
-    pub struct ChatPanelStory;
-
-    impl Render<Self> for ChatPanelStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, ChatPanel>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(
-                    Panel::new("chat-panel-1-outer", cx)
-                        .child(ChatPanel::new("chat-panel-1-inner")),
-                )
-                .child(Story::label(cx, "With Mesages"))
-                .child(Panel::new("chat-panel-2-outer", cx).child(
-                    ChatPanel::new("chat-panel-2-inner").messages(vec![
-                        ChatMessage::new(
-                            "osiewicz".to_string(),
-                            "is this thing on?".to_string(),
-                            DateTime::parse_from_rfc3339("2023-09-27T15:40:52.707Z")
-                                .unwrap()
-                                .naive_local(),
-                        ),
-                        ChatMessage::new(
-                            "maxdeviant".to_string(),
-                            "Reading you loud and clear!".to_string(),
-                            DateTime::parse_from_rfc3339("2023-09-28T15:40:52.707Z")
-                                .unwrap()
-                                .naive_local(),
-                        ),
-                    ]),
-                ))
-        }
-    }
-}

crates/ui2/src/to_extract/collab_panel.rs

@@ -1,114 +0,0 @@
-use crate::{
-    prelude::*, static_collab_panel_channels, static_collab_panel_current_call, v_stack, Icon,
-    List, ListHeader, Toggle,
-};
-use gpui::{prelude::*, Div, Stateful};
-
-#[derive(RenderOnce)]
-pub struct CollabPanel {
-    id: ElementId,
-}
-
-impl<V: 'static> Component<V> for CollabPanel {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        v_stack()
-            .id(self.id.clone())
-            .h_full()
-            .bg(cx.theme().colors().surface_background)
-            .child(
-                v_stack()
-                    .id("crdb")
-                    .w_full()
-                    .overflow_y_scroll()
-                    .child(
-                        div()
-                            .pb_1()
-                            .border_color(cx.theme().colors().border)
-                            .border_b()
-                            .child(
-                                List::new(static_collab_panel_current_call())
-                                    .header(
-                                        ListHeader::new("CRDB")
-                                            .left_icon(Icon::Hash.into())
-                                            .toggle(Toggle::Toggled(true)),
-                                    )
-                                    .toggle(Toggle::Toggled(true)),
-                            ),
-                    )
-                    .child(
-                        v_stack().id("channels").py_1().child(
-                            List::new(static_collab_panel_channels())
-                                .header(ListHeader::new("CHANNELS").toggle(Toggle::Toggled(true)))
-                                .empty_message("No channels yet. Add a channel to get started.")
-                                .toggle(Toggle::Toggled(true)),
-                        ),
-                    )
-                    .child(
-                        v_stack().id("contacts-online").py_1().child(
-                            List::new(static_collab_panel_current_call())
-                                .header(
-                                    ListHeader::new("CONTACTS – ONLINE")
-                                        .toggle(Toggle::Toggled(true)),
-                                )
-                                .toggle(Toggle::Toggled(true)),
-                        ),
-                    )
-                    .child(
-                        v_stack().id("contacts-offline").py_1().child(
-                            List::new(static_collab_panel_current_call())
-                                .header(
-                                    ListHeader::new("CONTACTS – OFFLINE")
-                                        .toggle(Toggle::Toggled(false)),
-                                )
-                                .toggle(Toggle::Toggled(false)),
-                        ),
-                    ),
-            )
-            .child(
-                div()
-                    .h_7()
-                    .px_2()
-                    .border_t()
-                    .border_color(cx.theme().colors().border)
-                    .flex()
-                    .items_center()
-                    .child(
-                        div()
-                            .text_ui_sm()
-                            .text_color(cx.theme().colors().text_placeholder)
-                            .child("Find..."),
-                    ),
-            )
-    }
-}
-
-impl CollabPanel {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self { id: id.into() }
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-    use gpui::{Div, Render};
-
-    pub struct CollabPanelStory;
-
-    impl Render<Self> for CollabPanelStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, CollabPanel>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(CollabPanel::new("collab-panel"))
-        }
-    }
-}

crates/ui2/src/to_extract/command_palette.rs

@@ -1,53 +0,0 @@
-use crate::prelude::*;
-use crate::{example_editor_actions, OrderMethod, Palette};
-
-#[derive(RenderOnce)]
-pub struct CommandPalette {
-    id: ElementId,
-}
-
-impl<V: 'static> Component<V> for CommandPalette {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div().id(self.id.clone()).child(
-            Palette::new("palette")
-                .items(example_editor_actions())
-                .placeholder("Execute a command...")
-                .empty_string("No items found.")
-                .default_order(OrderMethod::Ascending),
-        )
-    }
-}
-
-impl CommandPalette {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self { id: id.into() }
-    }
-}
-
-use gpui::{Div, RenderOnce, Stateful};
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use gpui::{Div, Render};
-
-    use crate::Story;
-
-    use super::*;
-
-    pub struct CommandPaletteStory;
-
-    impl Render<Self> for CommandPaletteStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, CommandPalette>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(CommandPalette::new("command-palette"))
-        }
-    }
-}

crates/ui2/src/to_extract/copilot.rs

@@ -1,49 +0,0 @@
-use crate::{prelude::*, Button, Label, Modal, TextColor};
-
-#[derive(RenderOnce)]
-pub struct CopilotModal {
-    id: ElementId,
-}
-
-impl<V: 'static> Component<V> for CopilotModal {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div().id(self.id.clone()).child(
-                Modal::new("some-id")
-                    .title("Connect Copilot to Zed")
-                    .child(Label::new("You can update your settings or sign out from the Copilot menu in the status bar.").color(TextColor::Muted))
-                    .primary_action(Button::new("Connect to Github").variant(ButtonVariant::Filled)),
-            )
-    }
-}
-
-impl CopilotModal {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self { id: id.into() }
-    }
-}
-
-use gpui::{Div, RenderOnce, Stateful};
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-    use gpui::{Div, Render};
-
-    pub struct CopilotModalStory;
-
-    impl Render<Self> for CopilotModalStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, CopilotModal>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(CopilotModal::new("copilot-modal"))
-        }
-    }
-}

crates/ui2/src/to_extract/editor_pane.rs

@@ -1,77 +0,0 @@
-use std::path::PathBuf;
-
-use gpui::{Div, Render, RenderOnce, View, VisualContext};
-
-use crate::prelude::*;
-use crate::{
-    hello_world_rust_editor_with_status_example, v_stack, Breadcrumb, Buffer, BufferSearch, Icon,
-    IconButton, Symbol, Tab, TabBar, TextColor, Toolbar,
-};
-
-#[derive(Clone)]
-pub struct EditorPane {
-    tabs: Vec<Tab>,
-    path: PathBuf,
-    symbols: Vec<Symbol>,
-    buffer: Buffer,
-    buffer_search: View<BufferSearch>,
-    is_buffer_search_open: bool,
-}
-
-impl EditorPane {
-    pub fn new(
-        cx: &mut ViewContext<Self>,
-        tabs: Vec<Tab>,
-        path: PathBuf,
-        symbols: Vec<Symbol>,
-        buffer: Buffer,
-    ) -> Self {
-        Self {
-            tabs,
-            path,
-            symbols,
-            buffer,
-            buffer_search: BufferSearch::view(cx),
-            is_buffer_search_open: false,
-        }
-    }
-
-    pub fn toggle_buffer_search(&mut self, cx: &mut ViewContext<Self>) {
-        self.is_buffer_search_open = !self.is_buffer_search_open;
-
-        cx.notify();
-    }
-
-    pub fn view(cx: &mut WindowContext) -> View<Self> {
-        cx.build_view(|cx| hello_world_rust_editor_with_status_example(cx))
-    }
-}
-
-impl Render<Self> for EditorPane {
-    type Element = Div<Self>;
-
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Div<Self> {
-        v_stack()
-            .w_full()
-            .h_full()
-            .flex_1()
-            .child(TabBar::new("editor-pane-tabs", self.tabs.clone()).can_navigate((false, true)))
-            .child(
-                Toolbar::new()
-                    .left_item(Breadcrumb::new(self.path.clone(), self.symbols.clone()))
-                    .right_items(vec![
-                        IconButton::<Self>::new("toggle_inlay_hints", Icon::InlayHint),
-                        IconButton::<Self>::new("buffer_search", Icon::MagnifyingGlass)
-                            .when(self.is_buffer_search_open, |this| {
-                                this.color(TextColor::Accent)
-                            })
-                            .on_click(|editor: &mut Self, cx| {
-                                editor.toggle_buffer_search(cx);
-                            }),
-                        IconButton::new("inline_assist", Icon::MagicWand),
-                    ]),
-            )
-            .children(Some(self.buffer_search.clone()).filter(|_| self.is_buffer_search_open))
-            .child(self.buffer.clone())
-    }
-}

crates/ui2/src/to_extract/language_selector.rs

@@ -1,83 +0,0 @@
-use crate::prelude::*;
-use crate::{OrderMethod, Palette, PaletteItem};
-
-#[derive(RenderOnce)]
-pub struct LanguageSelector {
-    id: ElementId,
-}
-
-impl<V: 'static> Component<V> for LanguageSelector {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div().id(self.id.clone()).child(
-            Palette::new("palette")
-                .items(vec![
-                    PaletteItem::new("C"),
-                    PaletteItem::new("C++"),
-                    PaletteItem::new("CSS"),
-                    PaletteItem::new("Elixir"),
-                    PaletteItem::new("Elm"),
-                    PaletteItem::new("ERB"),
-                    PaletteItem::new("Rust (current)"),
-                    PaletteItem::new("Scheme"),
-                    PaletteItem::new("TOML"),
-                    PaletteItem::new("TypeScript"),
-                ])
-                .placeholder("Select a language...")
-                .empty_string("No matches")
-                .default_order(OrderMethod::Ascending),
-        )
-    }
-}
-
-impl LanguageSelector {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self { id: id.into() }
-    }
-
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
-        div().id(self.id.clone()).child(
-            Palette::new("palette")
-                .items(vec![
-                    PaletteItem::new("C"),
-                    PaletteItem::new("C++"),
-                    PaletteItem::new("CSS"),
-                    PaletteItem::new("Elixir"),
-                    PaletteItem::new("Elm"),
-                    PaletteItem::new("ERB"),
-                    PaletteItem::new("Rust (current)"),
-                    PaletteItem::new("Scheme"),
-                    PaletteItem::new("TOML"),
-                    PaletteItem::new("TypeScript"),
-                ])
-                .placeholder("Select a language...")
-                .empty_string("No matches")
-                .default_order(OrderMethod::Ascending),
-        )
-    }
-}
-
-use gpui::{Div, RenderOnce, Stateful};
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-    use gpui::{Div, Render};
-
-    pub struct LanguageSelectorStory;
-
-    impl Render<Self> for LanguageSelectorStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, LanguageSelector>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(LanguageSelector::new("language-selector"))
-        }
-    }
-}

crates/ui2/src/to_extract/multi_buffer.rs

@@ -1,68 +0,0 @@
-use crate::prelude::*;
-use crate::{v_stack, Buffer, Icon, IconButton, Label};
-
-#[derive(RenderOnce)]
-pub struct MultiBuffer {
-    buffers: Vec<Buffer>,
-}
-
-impl<V: 'static> Component<V> for MultiBuffer {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        v_stack()
-            .w_full()
-            .h_full()
-            .flex_1()
-            .children(self.buffers.clone().into_iter().map(|buffer| {
-                v_stack()
-                    .child(
-                        div()
-                            .flex()
-                            .items_center()
-                            .justify_between()
-                            .p_4()
-                            .bg(cx.theme().colors().editor_subheader_background)
-                            .child(Label::new("main.rs"))
-                            .child(IconButton::new("arrow_up_right", Icon::ArrowUpRight)),
-                    )
-                    .child(buffer)
-            }))
-    }
-}
-
-impl MultiBuffer {
-    pub fn new(buffers: Vec<Buffer>) -> Self {
-        Self { buffers }
-    }
-}
-
-use gpui::{Div, RenderOnce};
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::{hello_world_rust_buffer_example, Story};
-    use gpui::{Div, Render};
-
-    pub struct MultiBufferStory;
-
-    impl Render<Self> for MultiBufferStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, MultiBuffer>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(MultiBuffer::new(vec![
-                    hello_world_rust_buffer_example(cx),
-                    hello_world_rust_buffer_example(cx),
-                    hello_world_rust_buffer_example(cx),
-                    hello_world_rust_buffer_example(cx),
-                    hello_world_rust_buffer_example(cx),
-                ]))
-        }
-    }
-}

crates/ui2/src/to_extract/notifications_panel.rs

@@ -1,379 +0,0 @@
-use crate::{
-    h_stack, prelude::*, static_new_notification_items_2, utils::naive_format_distance_from_now,
-    v_stack, Avatar, ButtonOrIconButton, ClickHandler, Icon, IconElement, Label, LineHeightStyle,
-    ListHeader, ListHeaderMeta, ListSeparator, PublicPlayer, TextColor, UnreadIndicator,
-};
-use gpui::{prelude::*, Div, Stateful};
-
-#[derive(RenderOnce)]
-pub struct NotificationsPanel {
-    id: ElementId,
-}
-
-impl<V: 'static> Component<V> for NotificationsPanel {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div()
-            .id(self.id.clone())
-            .flex()
-            .flex_col()
-            .size_full()
-            .bg(cx.theme().colors().surface_background)
-            .child(
-                ListHeader::new("Notifications").meta(Some(ListHeaderMeta::Tools(vec![
-                    Icon::AtSign,
-                    Icon::BellOff,
-                    Icon::MailOpen,
-                ]))),
-            )
-            .child(ListSeparator::new())
-            .child(
-                v_stack()
-                    .id("notifications-panel-scroll-view")
-                    .py_1()
-                    .overflow_y_scroll()
-                    .flex_1()
-                    .child(
-                        div()
-                            .mx_2()
-                            .p_1()
-                            // TODO: Add cursor style
-                            // .cursor(Cursor::IBeam)
-                            .bg(cx.theme().colors().element_background)
-                            .border()
-                            .border_color(cx.theme().colors().border_variant)
-                            .child(
-                                Label::new("Search...")
-                                    .color(TextColor::Placeholder)
-                                    .line_height_style(LineHeightStyle::UILabel),
-                            ),
-                    )
-                    .child(v_stack().px_1().children(static_new_notification_items_2())),
-            )
-    }
-}
-
-impl NotificationsPanel {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self { id: id.into() }
-    }
-}
-
-pub struct NotificationAction<V: 'static> {
-    button: ButtonOrIconButton<V>,
-    tooltip: SharedString,
-    /// Shows after action is chosen
-    ///
-    /// For example, if the action is "Accept" the taken message could be:
-    ///
-    /// - `(None,"Accepted")` - "Accepted"
-    ///
-    /// - `(Some(Icon::Check),"Accepted")` - ✓ "Accepted"
-    taken_message: (Option<Icon>, SharedString),
-}
-
-impl<V: 'static> NotificationAction<V> {
-    pub fn new(
-        button: impl Into<ButtonOrIconButton<V>>,
-        tooltip: impl Into<SharedString>,
-        (icon, taken_message): (Option<Icon>, impl Into<SharedString>),
-    ) -> Self {
-        Self {
-            button: button.into(),
-            tooltip: tooltip.into(),
-            taken_message: (icon, taken_message.into()),
-        }
-    }
-}
-
-pub enum ActorOrIcon {
-    Actor(PublicPlayer),
-    Icon(Icon),
-}
-
-pub struct NotificationMeta<V: 'static> {
-    items: Vec<(Option<Icon>, SharedString, Option<ClickHandler<V>>)>,
-}
-
-struct NotificationHandlers<V: 'static> {
-    click: Option<ClickHandler<V>>,
-}
-
-impl<V: 'static> Default for NotificationHandlers<V> {
-    fn default() -> Self {
-        Self { click: None }
-    }
-}
-
-#[derive(RenderOnce)]
-pub struct Notification<V: 'static> {
-    id: ElementId,
-    slot: ActorOrIcon,
-    message: SharedString,
-    date_received: NaiveDateTime,
-    meta: Option<NotificationMeta<V>>,
-    actions: Option<[NotificationAction<V>; 2]>,
-    unread: bool,
-    new: bool,
-    action_taken: Option<NotificationAction<V>>,
-    handlers: NotificationHandlers<V>,
-}
-
-impl<V: 'static> Component<V> for Notification<V> {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div()
-            .relative()
-            .id(self.id.clone())
-            .p_1()
-            .flex()
-            .flex_col()
-            .w_full()
-            .children(
-                Some(
-                    div()
-                        .absolute()
-                        .left(px(3.0))
-                        .top_3()
-                        .z_index(2)
-                        .child(UnreadIndicator::new()),
-                )
-                .filter(|_| self.unread),
-            )
-            .child(
-                v_stack()
-                    .z_index(1)
-                    .gap_1()
-                    .w_full()
-                    .child(
-                        h_stack()
-                            .w_full()
-                            .gap_2()
-                            .child(self.render_slot(cx))
-                            .child(div().flex_1().child(Label::new(self.message.clone()))),
-                    )
-                    .child(
-                        h_stack()
-                            .justify_between()
-                            .child(
-                                h_stack()
-                                    .gap_1()
-                                    .child(
-                                        Label::new(naive_format_distance_from_now(
-                                            self.date_received,
-                                            true,
-                                            true,
-                                        ))
-                                        .color(TextColor::Muted),
-                                    )
-                                    .child(self.render_meta_items(cx)),
-                            )
-                            .child(match (self.actions, self.action_taken) {
-                                // Show nothing
-                                (None, _) => div(),
-                                // Show the taken_message
-                                (Some(_), Some(action_taken)) => h_stack()
-                                    .children(action_taken.taken_message.0.map(|icon| {
-                                        IconElement::new(icon).color(crate::TextColor::Muted)
-                                    }))
-                                    .child(
-                                        Label::new(action_taken.taken_message.1.clone())
-                                            .color(TextColor::Muted),
-                                    ),
-                                // Show the actions
-                                (Some(actions), None) => {
-                                    h_stack().children(actions.map(|action| match action.button {
-                                        ButtonOrIconButton::Button(button) => {
-                                            button.render_into_any()
-                                        }
-                                        ButtonOrIconButton::IconButton(icon_button) => {
-                                            icon_button.render_into_any()
-                                        }
-                                    }))
-                                }
-                            }),
-                    ),
-            )
-    }
-}
-
-impl<V> Notification<V> {
-    fn new(
-        id: ElementId,
-        message: SharedString,
-        date_received: NaiveDateTime,
-        slot: ActorOrIcon,
-        click_action: Option<ClickHandler<V>>,
-    ) -> Self {
-        let handlers = if click_action.is_some() {
-            NotificationHandlers {
-                click: click_action,
-            }
-        } else {
-            NotificationHandlers::default()
-        };
-
-        Self {
-            id,
-            date_received,
-            message,
-            meta: None,
-            slot,
-            actions: None,
-            unread: true,
-            new: false,
-            action_taken: None,
-            handlers,
-        }
-    }
-
-    /// Creates a new notification with an actor slot.
-    ///
-    /// Requires a click action.
-    pub fn new_actor_message(
-        id: impl Into<ElementId>,
-        message: impl Into<SharedString>,
-        date_received: NaiveDateTime,
-        actor: PublicPlayer,
-        click_action: ClickHandler<V>,
-    ) -> Self {
-        Self::new(
-            id.into(),
-            message.into(),
-            date_received,
-            ActorOrIcon::Actor(actor),
-            Some(click_action),
-        )
-    }
-
-    /// Creates a new notification with an icon slot.
-    ///
-    /// Requires a click action.
-    pub fn new_icon_message(
-        id: impl Into<ElementId>,
-        message: impl Into<SharedString>,
-        date_received: NaiveDateTime,
-        icon: Icon,
-        click_action: ClickHandler<V>,
-    ) -> Self {
-        Self::new(
-            id.into(),
-            message.into(),
-            date_received,
-            ActorOrIcon::Icon(icon),
-            Some(click_action),
-        )
-    }
-
-    /// Creates a new notification with an actor slot
-    /// and a Call To Action row.
-    ///
-    /// Cannot take a click action due to required actions.
-    pub fn new_actor_with_actions(
-        id: impl Into<ElementId>,
-        message: impl Into<SharedString>,
-        date_received: NaiveDateTime,
-        actor: PublicPlayer,
-        actions: [NotificationAction<V>; 2],
-    ) -> Self {
-        Self::new(
-            id.into(),
-            message.into(),
-            date_received,
-            ActorOrIcon::Actor(actor),
-            None,
-        )
-        .actions(actions)
-    }
-
-    /// Creates a new notification with an icon slot
-    /// and a Call To Action row.
-    ///
-    /// Cannot take a click action due to required actions.
-    pub fn new_icon_with_actions(
-        id: impl Into<ElementId>,
-        message: impl Into<SharedString>,
-        date_received: NaiveDateTime,
-        icon: Icon,
-        actions: [NotificationAction<V>; 2],
-    ) -> Self {
-        Self::new(
-            id.into(),
-            message.into(),
-            date_received,
-            ActorOrIcon::Icon(icon),
-            None,
-        )
-        .actions(actions)
-    }
-
-    fn on_click(mut self, handler: ClickHandler<V>) -> Self {
-        self.handlers.click = Some(handler);
-        self
-    }
-
-    pub fn actions(mut self, actions: [NotificationAction<V>; 2]) -> Self {
-        self.actions = Some(actions);
-        self
-    }
-
-    pub fn meta(mut self, meta: NotificationMeta<V>) -> Self {
-        self.meta = Some(meta);
-        self
-    }
-
-    fn render_meta_items(&self, cx: &mut ViewContext<V>) -> impl Element<V> {
-        if let Some(meta) = &self.meta {
-            h_stack().children(
-                meta.items
-                    .iter()
-                    .map(|(icon, text, _)| {
-                        let mut meta_el = div();
-                        if let Some(icon) = icon {
-                            meta_el = meta_el.child(IconElement::new(icon.clone()));
-                        }
-                        meta_el.child(Label::new(text.clone()).color(TextColor::Muted))
-                    })
-                    .collect::<Vec<_>>(),
-            )
-        } else {
-            div()
-        }
-    }
-
-    fn render_slot(&self, cx: &mut ViewContext<V>) -> impl Element<V> {
-        match &self.slot {
-            ActorOrIcon::Actor(actor) => Avatar::new(actor.avatar.clone()).render_into_any(),
-            ActorOrIcon::Icon(icon) => IconElement::new(icon.clone()).render_into_any(),
-        }
-    }
-}
-
-use chrono::NaiveDateTime;
-use gpui::{px, Styled};
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::{Panel, Story};
-    use gpui::{Div, Render};
-
-    pub struct NotificationsPanelStory;
-
-    impl Render<Self> for NotificationsPanelStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, NotificationsPanel>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(
-                    Panel::new("panel", cx).child(NotificationsPanel::new("notifications_panel")),
-                )
-        }
-    }
-}

crates/ui2/src/to_extract/panes.rs

@@ -1,139 +0,0 @@
-use gpui::{
-    hsla, red, AnyElement, Div, ElementId, ExternalPaths, Hsla, Length, RenderOnce, Size, Stateful,
-    View,
-};
-use smallvec::SmallVec;
-
-use crate::prelude::*;
-
-#[derive(Default, PartialEq)]
-pub enum SplitDirection {
-    #[default]
-    Horizontal,
-    Vertical,
-}
-
-#[derive(RenderOnce)]
-pub struct Pane<V: 'static> {
-    id: ElementId,
-    size: Size<Length>,
-    fill: Hsla,
-    children: SmallVec<[AnyElement<V>; 2]>,
-}
-
-impl<V: 'static> Component<V> for Pane<V> {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div()
-            .id(self.id.clone())
-            .flex()
-            .flex_initial()
-            .bg(self.fill)
-            .w(self.size.width)
-            .h(self.size.height)
-            .relative()
-            .child(div().z_index(0).size_full().children(self.children))
-            .child(
-                div()
-                    .z_index(1)
-                    .id("drag-target")
-                    .drag_over::<ExternalPaths>(|d| d.bg(red()))
-                    .on_drop(|_, files: View<ExternalPaths>, cx| {
-                        eprintln!("dropped files! {:?}", files.read(cx));
-                    })
-                    .absolute()
-                    .inset_0(),
-            )
-    }
-}
-
-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(),
-            size,
-            fill: hsla(0.3, 0.3, 0.3, 1.),
-            children: SmallVec::new(),
-        }
-    }
-
-    pub fn fill(mut self, fill: Hsla) -> Self {
-        self.fill = fill;
-        self
-    }
-}
-
-impl<V: 'static> ParentElement<V> for Pane<V> {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
-        &mut self.children
-    }
-}
-
-#[derive(RenderOnce)]
-pub struct PaneGroup<V: 'static> {
-    groups: Vec<PaneGroup<V>>,
-    panes: Vec<Pane<V>>,
-    split_direction: SplitDirection,
-}
-
-impl<V: 'static> Component<V> for PaneGroup<V> {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        if !self.panes.is_empty() {
-            let el = div()
-                .flex()
-                .flex_1()
-                .gap_px()
-                .w_full()
-                .h_full()
-                .children(self.panes.into_iter().map(|pane| pane.render(view, cx)));
-
-            if self.split_direction == SplitDirection::Horizontal {
-                return el;
-            } else {
-                return el.flex_col();
-            }
-        }
-
-        if !self.groups.is_empty() {
-            let el = div()
-                .flex()
-                .flex_1()
-                .gap_px()
-                .w_full()
-                .h_full()
-                .bg(cx.theme().colors().editor_background)
-                .children(self.groups.into_iter().map(|group| group.render(view, cx)));
-
-            if self.split_direction == SplitDirection::Horizontal {
-                return el;
-            } else {
-                return el.flex_col();
-            }
-        }
-
-        unreachable!()
-    }
-}
-
-impl<V: 'static> PaneGroup<V> {
-    pub fn new_groups(groups: Vec<PaneGroup<V>>, split_direction: SplitDirection) -> Self {
-        Self {
-            groups,
-            panes: Vec::new(),
-            split_direction,
-        }
-    }
-
-    pub fn new_panes(panes: Vec<Pane<V>>, split_direction: SplitDirection) -> Self {
-        Self {
-            groups: Vec::new(),
-            panes,
-            split_direction,
-        }
-    }
-}

crates/ui2/src/to_extract/project_panel.rs

@@ -1,113 +0,0 @@
-use crate::{
-    prelude::*, static_project_panel_project_items, static_project_panel_single_items, Input, List,
-    ListHeader,
-};
-use gpui::prelude::*;
-use gpui::Div;
-use gpui::Stateful;
-
-#[derive(RenderOnce)]
-pub struct ProjectPanel {
-    id: ElementId,
-}
-
-impl<V: 'static> Component<V> for ProjectPanel {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div()
-            .id(self.id.clone())
-            .flex()
-            .flex_col()
-            .size_full()
-            .bg(cx.theme().colors().surface_background)
-            .child(
-                div()
-                    .id("project-panel-contents")
-                    .w_full()
-                    .flex()
-                    .flex_col()
-                    .overflow_y_scroll()
-                    .child(
-                        List::new(static_project_panel_single_items())
-                            .header(ListHeader::new("FILES"))
-                            .empty_message("No files in directory"),
-                    )
-                    .child(
-                        List::new(static_project_panel_project_items())
-                            .header(ListHeader::new("PROJECT"))
-                            .empty_message("No folders in directory"),
-                    ),
-            )
-            .child(
-                Input::new("Find something...")
-                    .value("buffe".to_string())
-                    .state(InteractionState::Focused),
-            )
-    }
-}
-
-impl ProjectPanel {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self { id: id.into() }
-    }
-
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
-        div()
-            .id(self.id.clone())
-            .flex()
-            .flex_col()
-            .size_full()
-            .bg(cx.theme().colors().surface_background)
-            .child(
-                div()
-                    .id("project-panel-contents")
-                    .w_full()
-                    .flex()
-                    .flex_col()
-                    .overflow_y_scroll()
-                    .child(
-                        List::new(static_project_panel_single_items())
-                            .header(ListHeader::new("FILES"))
-                            .empty_message("No files in directory"),
-                    )
-                    .child(
-                        List::new(static_project_panel_project_items())
-                            .header(ListHeader::new("PROJECT"))
-                            .empty_message("No folders in directory"),
-                    ),
-            )
-            .child(
-                Input::new("Find something...")
-                    .value("buffe".to_string())
-                    .state(InteractionState::Focused),
-            )
-    }
-}
-
-use gpui::ElementId;
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::{Panel, Story};
-    use gpui::{Div, Render};
-
-    pub struct ProjectPanelStory;
-
-    impl Render<Self> for ProjectPanelStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, ProjectPanel>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(
-                    Panel::new("project-panel-outer", cx)
-                        .child(ProjectPanel::new("project-panel-inner")),
-                )
-        }
-    }
-}

crates/ui2/src/to_extract/recent_projects.rs

@@ -1,58 +0,0 @@
-use crate::prelude::*;
-use crate::{OrderMethod, Palette, PaletteItem};
-
-#[derive(RenderOnce)]
-pub struct RecentProjects {
-    id: ElementId,
-}
-
-impl<V: 'static> Component<V> for RecentProjects {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div().id(self.id.clone()).child(
-            Palette::new("palette")
-                .items(vec![
-                    PaletteItem::new("zed").sublabel(SharedString::from("~/projects/zed")),
-                    PaletteItem::new("saga").sublabel(SharedString::from("~/projects/saga")),
-                    PaletteItem::new("journal").sublabel(SharedString::from("~/journal")),
-                    PaletteItem::new("dotfiles").sublabel(SharedString::from("~/dotfiles")),
-                    PaletteItem::new("zed.dev").sublabel(SharedString::from("~/projects/zed.dev")),
-                    PaletteItem::new("laminar").sublabel(SharedString::from("~/projects/laminar")),
-                ])
-                .placeholder("Recent Projects...")
-                .empty_string("No matches")
-                .default_order(OrderMethod::Ascending),
-        )
-    }
-}
-
-impl RecentProjects {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self { id: id.into() }
-    }
-}
-
-use gpui::{Div, RenderOnce, Stateful};
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-    use gpui::{Div, Render};
-
-    pub struct RecentProjectsStory;
-
-    impl Render<Self> for RecentProjectsStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, RecentProjects>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(RecentProjects::new("recent-projects"))
-        }
-    }
-}

crates/ui2/src/to_extract/status_bar.rs

@@ -1,201 +0,0 @@
-use std::sync::Arc;
-
-use gpui::{Div, RenderOnce};
-
-use crate::prelude::*;
-use crate::{Button, Icon, IconButton, TextColor, ToolDivider, Workspace};
-
-#[derive(Default, PartialEq)]
-pub enum Tool {
-    #[default]
-    ProjectPanel,
-    CollaborationPanel,
-    Terminal,
-    Assistant,
-    Feedback,
-    Diagnostics,
-}
-
-struct ToolGroup {
-    active_index: Option<usize>,
-    tools: Vec<Tool>,
-}
-
-impl Default for ToolGroup {
-    fn default() -> Self {
-        ToolGroup {
-            active_index: None,
-            tools: vec![],
-        }
-    }
-}
-
-#[derive(RenderOnce)]
-#[view = "Workspace"]
-pub struct StatusBar {
-    left_tools: Option<ToolGroup>,
-    right_tools: Option<ToolGroup>,
-    bottom_tools: Option<ToolGroup>,
-}
-
-impl Component<Workspace> for StatusBar {
-    type Rendered = Div<Workspace>;
-
-    fn render(self, view: &mut Workspace, cx: &mut ViewContext<Workspace>) -> Self::Rendered {
-        div()
-            .py_0p5()
-            .px_1()
-            .flex()
-            .items_center()
-            .justify_between()
-            .w_full()
-            .bg(cx.theme().colors().status_bar_background)
-            .child(self.left_tools(view, cx))
-            .child(self.right_tools(view, cx))
-    }
-}
-
-impl StatusBar {
-    pub fn new() -> Self {
-        Self {
-            left_tools: None,
-            right_tools: None,
-            bottom_tools: None,
-        }
-    }
-
-    pub fn left_tool(mut self, tool: Tool, active_index: Option<usize>) -> Self {
-        self.left_tools = {
-            let mut tools = vec![tool];
-            tools.extend(self.left_tools.take().unwrap_or_default().tools);
-            Some(ToolGroup {
-                active_index,
-                tools,
-            })
-        };
-        self
-    }
-
-    pub fn right_tool(mut self, tool: Tool, active_index: Option<usize>) -> Self {
-        self.right_tools = {
-            let mut tools = vec![tool];
-            tools.extend(self.left_tools.take().unwrap_or_default().tools);
-            Some(ToolGroup {
-                active_index,
-                tools,
-            })
-        };
-        self
-    }
-
-    pub fn bottom_tool(mut self, tool: Tool, active_index: Option<usize>) -> Self {
-        self.bottom_tools = {
-            let mut tools = vec![tool];
-            tools.extend(self.left_tools.take().unwrap_or_default().tools);
-            Some(ToolGroup {
-                active_index,
-                tools,
-            })
-        };
-        self
-    }
-
-    fn left_tools(&self, workspace: &mut Workspace, cx: &WindowContext) -> impl Element<Workspace> {
-        div()
-            .flex()
-            .items_center()
-            .gap_1()
-            .child(
-                IconButton::<Workspace>::new("project_panel", Icon::FileTree)
-                    .when(workspace.is_project_panel_open(), |this| {
-                        this.color(TextColor::Accent)
-                    })
-                    .on_click(|workspace: &mut Workspace, cx| {
-                        workspace.toggle_project_panel(cx);
-                    }),
-            )
-            .child(
-                IconButton::<Workspace>::new("collab_panel", Icon::Hash)
-                    .when(workspace.is_collab_panel_open(), |this| {
-                        this.color(TextColor::Accent)
-                    })
-                    .on_click(|workspace: &mut Workspace, cx| {
-                        workspace.toggle_collab_panel();
-                    }),
-            )
-            .child(ToolDivider::new())
-            .child(IconButton::new("diagnostics", Icon::XCircle))
-    }
-
-    fn right_tools(
-        &self,
-        workspace: &mut Workspace,
-        cx: &WindowContext,
-    ) -> impl Element<Workspace> {
-        div()
-            .flex()
-            .items_center()
-            .gap_2()
-            .child(
-                div()
-                    .flex()
-                    .items_center()
-                    .gap_1()
-                    .child(Button::new("116:25"))
-                    .child(
-                        Button::<Workspace>::new("Rust").on_click(Arc::new(|workspace, cx| {
-                            workspace.toggle_language_selector(cx);
-                        })),
-                    ),
-            )
-            .child(ToolDivider::new())
-            .child(
-                div()
-                    .flex()
-                    .items_center()
-                    .gap_1()
-                    .child(
-                        IconButton::new("copilot", Icon::Copilot)
-                            .on_click(|_, _| println!("Copilot clicked.")),
-                    )
-                    .child(
-                        IconButton::new("envelope", Icon::Envelope)
-                            .on_click(|_, _| println!("Send Feedback clicked.")),
-                    ),
-            )
-            .child(ToolDivider::new())
-            .child(
-                div()
-                    .flex()
-                    .items_center()
-                    .gap_1()
-                    .child(
-                        IconButton::<Workspace>::new("terminal", Icon::Terminal)
-                            .when(workspace.is_terminal_open(), |this| {
-                                this.color(TextColor::Accent)
-                            })
-                            .on_click(|workspace: &mut Workspace, cx| {
-                                workspace.toggle_terminal(cx);
-                            }),
-                    )
-                    .child(
-                        IconButton::<Workspace>::new("chat_panel", Icon::MessageBubbles)
-                            .when(workspace.is_chat_panel_open(), |this| {
-                                this.color(TextColor::Accent)
-                            })
-                            .on_click(|workspace: &mut Workspace, cx| {
-                                workspace.toggle_chat_panel(cx);
-                            }),
-                    )
-                    .child(
-                        IconButton::<Workspace>::new("assistant_panel", Icon::Ai)
-                            .when(workspace.is_assistant_panel_open(), |this| {
-                                this.color(TextColor::Accent)
-                            })
-                            .on_click(|workspace: &mut Workspace, cx| {
-                                workspace.toggle_assistant_panel(cx);
-                            }),
-                    ),
-            )
-    }
-}

crates/ui2/src/to_extract/tab_bar.rs

@@ -1,156 +0,0 @@
-use crate::{prelude::*, Icon, IconButton, Tab};
-use gpui::prelude::*;
-use gpui::Div;
-use gpui::Stateful;
-
-#[derive(RenderOnce)]
-pub struct TabBar {
-    id: ElementId,
-    /// Backwards, Forwards
-    can_navigate: (bool, bool),
-    tabs: Vec<Tab>,
-}
-
-impl<V: 'static> Component<V> for TabBar {
-    type Rendered = Stateful<V, Div<V>>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let (can_navigate_back, can_navigate_forward) = self.can_navigate;
-
-        div()
-            .group("tab_bar")
-            .id(self.id.clone())
-            .w_full()
-            .flex()
-            .bg(cx.theme().colors().tab_bar_background)
-            // Left Side
-            .child(
-                div()
-                    .relative()
-                    .px_1()
-                    .flex()
-                    .flex_none()
-                    .gap_2()
-                    // Nav Buttons
-                    .child(
-                        div()
-                            .right_0()
-                            .flex()
-                            .items_center()
-                            .gap_px()
-                            .child(
-                                IconButton::new("arrow_left", Icon::ArrowLeft)
-                                    .state(InteractionState::Enabled.if_enabled(can_navigate_back)),
-                            )
-                            .child(
-                                IconButton::new("arrow_right", Icon::ArrowRight).state(
-                                    InteractionState::Enabled.if_enabled(can_navigate_forward),
-                                ),
-                            ),
-                    ),
-            )
-            .child(
-                div().w_0().flex_1().h_full().child(
-                    div()
-                        .id("tabs")
-                        .flex()
-                        .overflow_x_scroll()
-                        .children(self.tabs.clone()),
-                ),
-            )
-            // Right Side
-            .child(
-                div()
-                    // We only use absolute here since we don't
-                    // have opacity or `hidden()` yet
-                    .absolute()
-                    .neg_top_7()
-                    .px_1()
-                    .flex()
-                    .flex_none()
-                    .gap_2()
-                    .group_hover("tab_bar", |this| this.top_0())
-                    // Nav Buttons
-                    .child(
-                        div()
-                            .flex()
-                            .items_center()
-                            .gap_px()
-                            .child(IconButton::new("plus", Icon::Plus))
-                            .child(IconButton::new("split", Icon::Split)),
-                    ),
-            )
-    }
-}
-
-impl TabBar {
-    pub fn new(id: impl Into<ElementId>, tabs: Vec<Tab>) -> Self {
-        Self {
-            id: id.into(),
-            can_navigate: (false, false),
-            tabs,
-        }
-    }
-
-    pub fn can_navigate(mut self, can_navigate: (bool, bool)) -> Self {
-        self.can_navigate = can_navigate;
-        self
-    }
-}
-
-use gpui::ElementId;
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-    use gpui::{Div, Render};
-
-    pub struct TabBarStory;
-
-    impl Render<Self> for TabBarStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, TabBar>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(TabBar::new(
-                    "tab-bar",
-                    vec![
-                        Tab::new(1)
-                            .title("Cargo.toml".to_string())
-                            .current(false)
-                            .git_status(GitStatus::Modified),
-                        Tab::new(2)
-                            .title("Channels Panel".to_string())
-                            .current(false),
-                        Tab::new(3)
-                            .title("channels_panel.rs".to_string())
-                            .current(true)
-                            .git_status(GitStatus::Modified),
-                        Tab::new(4)
-                            .title("workspace.rs".to_string())
-                            .current(false)
-                            .git_status(GitStatus::Modified),
-                        Tab::new(5)
-                            .title("icon_button.rs".to_string())
-                            .current(false),
-                        Tab::new(6)
-                            .title("storybook.rs".to_string())
-                            .current(false)
-                            .git_status(GitStatus::Created),
-                        Tab::new(7).title("theme.rs".to_string()).current(false),
-                        Tab::new(8)
-                            .title("theme_registry.rs".to_string())
-                            .current(false),
-                        Tab::new(9)
-                            .title("styleable_helpers.rs".to_string())
-                            .current(false),
-                    ],
-                ))
-        }
-    }
-}

crates/ui2/src/to_extract/terminal.rs

@@ -1,166 +0,0 @@
-use crate::prelude::*;
-use crate::{Icon, IconButton, Pane, Tab};
-use gpui::{relative, rems, Div, RenderOnce, Size};
-
-#[derive(RenderOnce)]
-pub struct Terminal;
-
-impl<V: 'static> Component<V> for Terminal {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let can_navigate_back = true;
-        let can_navigate_forward = false;
-
-        div()
-            .flex()
-            .flex_col()
-            .w_full()
-            .child(
-                // Terminal Tabs.
-                div()
-                    .w_full()
-                    .flex()
-                    .bg(cx.theme().colors().surface_background)
-                    .child(
-                        div().px_1().flex().flex_none().gap_2().child(
-                            div()
-                                .flex()
-                                .items_center()
-                                .gap_px()
-                                .child(
-                                    IconButton::new("arrow_left", Icon::ArrowLeft).state(
-                                        InteractionState::Enabled.if_enabled(can_navigate_back),
-                                    ),
-                                )
-                                .child(IconButton::new("arrow_right", Icon::ArrowRight).state(
-                                    InteractionState::Enabled.if_enabled(can_navigate_forward),
-                                )),
-                        ),
-                    )
-                    .child(
-                        div().w_0().flex_1().h_full().child(
-                            div()
-                                .flex()
-                                .child(
-                                    Tab::new(1)
-                                        .title("zed — fish".to_string())
-                                        .icon(Icon::Terminal)
-                                        .close_side(IconSide::Right)
-                                        .current(true),
-                                )
-                                .child(
-                                    Tab::new(2)
-                                        .title("zed — fish".to_string())
-                                        .icon(Icon::Terminal)
-                                        .close_side(IconSide::Right)
-                                        .current(false),
-                                ),
-                        ),
-                    ),
-            )
-            // Terminal Pane.
-            .child(
-                Pane::new(
-                    "terminal",
-                    Size {
-                        width: relative(1.).into(),
-                        height: rems(36.).into(),
-                    },
-                )
-                .child(crate::static_data::terminal_buffer(cx)),
-            )
-    }
-}
-
-impl Terminal {
-    pub fn new() -> Self {
-        Self
-    }
-
-    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
-        let can_navigate_back = true;
-        let can_navigate_forward = false;
-
-        div()
-            .flex()
-            .flex_col()
-            .w_full()
-            .child(
-                // Terminal Tabs.
-                div()
-                    .w_full()
-                    .flex()
-                    .bg(cx.theme().colors().surface_background)
-                    .child(
-                        div().px_1().flex().flex_none().gap_2().child(
-                            div()
-                                .flex()
-                                .items_center()
-                                .gap_px()
-                                .child(
-                                    IconButton::new("arrow_left", Icon::ArrowLeft).state(
-                                        InteractionState::Enabled.if_enabled(can_navigate_back),
-                                    ),
-                                )
-                                .child(IconButton::new("arrow_right", Icon::ArrowRight).state(
-                                    InteractionState::Enabled.if_enabled(can_navigate_forward),
-                                )),
-                        ),
-                    )
-                    .child(
-                        div().w_0().flex_1().h_full().child(
-                            div()
-                                .flex()
-                                .child(
-                                    Tab::new(1)
-                                        .title("zed — fish".to_string())
-                                        .icon(Icon::Terminal)
-                                        .close_side(IconSide::Right)
-                                        .current(true),
-                                )
-                                .child(
-                                    Tab::new(2)
-                                        .title("zed — fish".to_string())
-                                        .icon(Icon::Terminal)
-                                        .close_side(IconSide::Right)
-                                        .current(false),
-                                ),
-                        ),
-                    ),
-            )
-            // Terminal Pane.
-            .child(
-                Pane::new(
-                    "terminal",
-                    Size {
-                        width: relative(1.).into(),
-                        height: rems(36.).into(),
-                    },
-                )
-                .child(crate::static_data::terminal_buffer(cx)),
-            )
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-    use gpui::{Div, Render};
-    pub struct TerminalStory;
-
-    impl Render<Self> for TerminalStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, Terminal>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(Terminal::new())
-        }
-    }
-}

crates/ui2/src/to_extract/theme_selector.rs

@@ -1,66 +0,0 @@
-use crate::prelude::*;
-use crate::{OrderMethod, Palette, PaletteItem};
-
-#[derive(RenderOnce)]
-pub struct ThemeSelector {
-    id: ElementId,
-}
-
-impl<V: 'static> Component<V> for ThemeSelector {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let cx: &mut ViewContext<V> = cx;
-        div().child(
-            Palette::new(self.id.clone())
-                .items(vec![
-                    PaletteItem::new("One Dark"),
-                    PaletteItem::new("Rosé Pine"),
-                    PaletteItem::new("Rosé Pine Moon"),
-                    PaletteItem::new("Sandcastle"),
-                    PaletteItem::new("Solarized Dark"),
-                    PaletteItem::new("Summercamp"),
-                    PaletteItem::new("Atelier Cave Light"),
-                    PaletteItem::new("Atelier Dune Light"),
-                    PaletteItem::new("Atelier Estuary Light"),
-                    PaletteItem::new("Atelier Forest Light"),
-                    PaletteItem::new("Atelier Heath Light"),
-                ])
-                .placeholder("Select Theme...")
-                .empty_string("No matches")
-                .default_order(OrderMethod::Ascending),
-        )
-    }
-}
-
-impl ThemeSelector {
-    pub fn new(id: impl Into<ElementId>) -> Self {
-        Self { id: id.into() }
-    }
-}
-
-use gpui::{Div, RenderOnce};
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use gpui::{Div, Render};
-
-    use crate::Story;
-
-    use super::*;
-
-    pub struct ThemeSelectorStory;
-
-    impl Render<Self> for ThemeSelectorStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, ThemeSelector>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(ThemeSelector::new("theme-selector"))
-        }
-    }
-}

crates/ui2/src/to_extract/title_bar.rs

@@ -1,218 +0,0 @@
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-
-use gpui::{Div, Render, RenderOnce, View, VisualContext};
-
-use crate::prelude::*;
-use crate::settings::user_settings;
-use crate::{
-    Avatar, Button, Icon, IconButton, MicStatus, PlayerStack, PlayerWithCallStatus,
-    ScreenShareStatus, TextColor, ToolDivider, TrafficLights,
-};
-
-#[derive(Clone)]
-pub struct Livestream {
-    pub players: Vec<PlayerWithCallStatus>,
-    pub channel: Option<String>, // projects
-                                 // windows
-}
-
-#[derive(Clone)]
-pub struct TitleBar {
-    /// If the window is active from the OS's perspective.
-    is_active: Arc<AtomicBool>,
-    livestream: Option<Livestream>,
-    mic_status: MicStatus,
-    is_deafened: bool,
-    screen_share_status: ScreenShareStatus,
-}
-
-impl TitleBar {
-    pub fn new(cx: &mut ViewContext<Self>) -> Self {
-        let is_active = Arc::new(AtomicBool::new(true));
-        let active = is_active.clone();
-
-        // cx.observe_window_activation(move |_, is_active, cx| {
-        //     active.store(is_active, std::sync::atomic::Ordering::SeqCst);
-        //     cx.notify();
-        // })
-        // .detach();
-
-        Self {
-            is_active,
-            livestream: None,
-            mic_status: MicStatus::Unmuted,
-            is_deafened: false,
-            screen_share_status: ScreenShareStatus::NotShared,
-        }
-    }
-
-    pub fn set_livestream(mut self, livestream: Option<Livestream>) -> Self {
-        self.livestream = livestream;
-        self
-    }
-
-    pub fn is_mic_muted(&self) -> bool {
-        self.mic_status == MicStatus::Muted
-    }
-
-    pub fn toggle_mic_status(&mut self, cx: &mut ViewContext<Self>) {
-        self.mic_status = self.mic_status.inverse();
-
-        // Undeafen yourself when unmuting the mic while deafened.
-        if self.is_deafened && self.mic_status == MicStatus::Unmuted {
-            self.is_deafened = false;
-        }
-
-        cx.notify();
-    }
-
-    pub fn toggle_deafened(&mut self, cx: &mut ViewContext<Self>) {
-        self.is_deafened = !self.is_deafened;
-        self.mic_status = MicStatus::Muted;
-
-        cx.notify()
-    }
-
-    pub fn toggle_screen_share_status(&mut self, cx: &mut ViewContext<Self>) {
-        self.screen_share_status = self.screen_share_status.inverse();
-
-        cx.notify();
-    }
-
-    pub fn view(cx: &mut WindowContext, livestream: Option<Livestream>) -> View<Self> {
-        cx.build_view(|cx| Self::new(cx).set_livestream(livestream))
-    }
-}
-
-impl Render<Self> for TitleBar {
-    type Element = Div<Self>;
-
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Div<Self> {
-        let settings = user_settings(cx);
-
-        // let has_focus = cx.window_is_active();
-        let has_focus = true;
-
-        let player_list = if let Some(livestream) = &self.livestream {
-            livestream.players.clone().into_iter()
-        } else {
-            vec![].into_iter()
-        };
-
-        div()
-            .flex()
-            .items_center()
-            .justify_between()
-            .w_full()
-            .bg(cx.theme().colors().background)
-            .py_1()
-            .child(
-                div()
-                    .flex()
-                    .items_center()
-                    .h_full()
-                    .gap_4()
-                    .px_2()
-                    .child(TrafficLights::new().window_has_focus(has_focus))
-                    // === Project Info === //
-                    .child(
-                        div()
-                            .flex()
-                            .items_center()
-                            .gap_1()
-                            .when(*settings.titlebar.show_project_owner, |this| {
-                                this.child(Button::new("iamnbutler"))
-                            })
-                            .child(Button::new("zed"))
-                            .child(Button::new("nate/gpui2-ui-components")),
-                    )
-                    .children(player_list.map(|p| PlayerStack::new(p)))
-                    .child(IconButton::new("plus", Icon::Plus)),
-            )
-            .child(
-                div()
-                    .flex()
-                    .items_center()
-                    .child(
-                        div()
-                            .px_2()
-                            .flex()
-                            .items_center()
-                            .gap_1()
-                            .child(IconButton::new("folder_x", Icon::FolderX))
-                            .child(IconButton::new("exit", Icon::Exit)),
-                    )
-                    .child(ToolDivider::new())
-                    .child(
-                        div()
-                            .px_2()
-                            .flex()
-                            .items_center()
-                            .gap_1()
-                            .child(
-                                IconButton::<TitleBar>::new("toggle_mic_status", Icon::Mic)
-                                    .when(self.is_mic_muted(), |this| this.color(TextColor::Error))
-                                    .on_click(|title_bar: &mut TitleBar, cx| {
-                                        title_bar.toggle_mic_status(cx)
-                                    }),
-                            )
-                            .child(
-                                IconButton::<TitleBar>::new("toggle_deafened", Icon::AudioOn)
-                                    .when(self.is_deafened, |this| this.color(TextColor::Error))
-                                    .on_click(|title_bar: &mut TitleBar, cx| {
-                                        title_bar.toggle_deafened(cx)
-                                    }),
-                            )
-                            .child(
-                                IconButton::<TitleBar>::new("toggle_screen_share", Icon::Screen)
-                                    .when(
-                                        self.screen_share_status == ScreenShareStatus::Shared,
-                                        |this| this.color(TextColor::Accent),
-                                    )
-                                    .on_click(|title_bar: &mut TitleBar, cx| {
-                                        title_bar.toggle_screen_share_status(cx)
-                                    }),
-                            ),
-                    )
-                    .child(
-                        div().px_2().flex().items_center().child(
-                            Avatar::new("https://avatars.githubusercontent.com/u/1714999?v=4")
-                                .shape(Shape::RoundedRectangle),
-                        ),
-                    ),
-            )
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use crate::Story;
-
-    pub struct TitleBarStory {
-        title_bar: View<TitleBar>,
-    }
-
-    impl TitleBarStory {
-        pub fn view(cx: &mut WindowContext) -> View<Self> {
-            cx.build_view(|cx| Self {
-                title_bar: TitleBar::view(cx, None),
-            })
-        }
-    }
-
-    impl Render<Self> for TitleBarStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Div<Self> {
-            Story::container(cx)
-                .child(Story::title_for::<_, TitleBar>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(self.title_bar.clone())
-        }
-    }
-}

crates/ui2/src/to_extract/toolbar.rs

@@ -1,130 +0,0 @@
-use gpui::{AnyElement, Div, RenderOnce};
-use smallvec::SmallVec;
-
-use crate::prelude::*;
-
-#[derive(Clone)]
-pub struct ToolbarItem {}
-
-#[derive(RenderOnce)]
-pub struct Toolbar<V: 'static> {
-    left_items: SmallVec<[AnyElement<V>; 2]>,
-    right_items: SmallVec<[AnyElement<V>; 2]>,
-}
-
-impl<V: 'static> Component<V> for Toolbar<V> {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div()
-            .bg(cx.theme().colors().toolbar_background)
-            .p_2()
-            .flex()
-            .justify_between()
-            .child(div().flex().children(self.left_items))
-            .child(div().flex().children(self.right_items))
-    }
-}
-
-impl<V: 'static> Toolbar<V> {
-    pub fn new() -> Self {
-        Self {
-            left_items: SmallVec::new(),
-            right_items: SmallVec::new(),
-        }
-    }
-
-    pub fn left_item(mut self, child: impl RenderOnce<V>) -> Self
-    where
-        Self: Sized,
-    {
-        self.left_items.push(child.render_into_any());
-        self
-    }
-
-    pub fn left_items(mut self, iter: impl IntoIterator<Item = impl RenderOnce<V>>) -> Self
-    where
-        Self: Sized,
-    {
-        self.left_items
-            .extend(iter.into_iter().map(|item| item.render_into_any()));
-        self
-    }
-
-    pub fn right_item(mut self, child: impl RenderOnce<V>) -> Self
-    where
-        Self: Sized,
-    {
-        self.right_items.push(child.render_into_any());
-        self
-    }
-
-    pub fn right_items(mut self, iter: impl IntoIterator<Item = impl RenderOnce<V>>) -> Self
-    where
-        Self: Sized,
-    {
-        self.right_items
-            .extend(iter.into_iter().map(|item| item.render_into_any()));
-        self
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use std::path::PathBuf;
-    use std::str::FromStr;
-
-    use gpui::{Div, Render};
-
-    use crate::{Breadcrumb, HighlightedText, Icon, IconButton, Story, Symbol};
-
-    use super::*;
-
-    pub struct ToolbarStory;
-
-    impl Render<Self> for ToolbarStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, Toolbar<Self>>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(
-                    Toolbar::new()
-                        .left_item(Breadcrumb::new(
-                            PathBuf::from_str("crates/ui/src/components/toolbar.rs").unwrap(),
-                            vec![
-                                Symbol(vec![
-                                    HighlightedText {
-                                        text: "impl ".into(),
-                                        color: cx.theme().syntax_color("keyword"),
-                                    },
-                                    HighlightedText {
-                                        text: "ToolbarStory".into(),
-                                        color: cx.theme().syntax_color("function"),
-                                    },
-                                ]),
-                                Symbol(vec![
-                                    HighlightedText {
-                                        text: "fn ".into(),
-                                        color: cx.theme().syntax_color("keyword"),
-                                    },
-                                    HighlightedText {
-                                        text: "render".into(),
-                                        color: cx.theme().syntax_color("function"),
-                                    },
-                                ]),
-                            ],
-                        ))
-                        .right_items(vec![
-                            IconButton::new("toggle_inlay_hints", Icon::InlayHint),
-                            IconButton::new("buffer_search", Icon::MagnifyingGlass),
-                            IconButton::new("inline_assist", Icon::MagicWand),
-                        ]),
-                )
-        }
-    }
-}

crates/ui2/src/to_extract/traffic_lights.rs

@@ -1,109 +0,0 @@
-use crate::prelude::*;
-
-#[derive(Clone, Copy)]
-enum TrafficLightColor {
-    Red,
-    Yellow,
-    Green,
-}
-
-#[derive(RenderOnce)]
-struct TrafficLight {
-    color: TrafficLightColor,
-    window_has_focus: bool,
-}
-
-impl<V: 'static> Component<V> for TrafficLight {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        let system_colors = &cx.theme().styles.system;
-
-        let fill = match (self.window_has_focus, self.color) {
-            (true, TrafficLightColor::Red) => system_colors.mac_os_traffic_light_red,
-            (true, TrafficLightColor::Yellow) => system_colors.mac_os_traffic_light_yellow,
-            (true, TrafficLightColor::Green) => system_colors.mac_os_traffic_light_green,
-            (false, _) => cx.theme().colors().element_background,
-        };
-
-        div().w_3().h_3().rounded_full().bg(fill)
-    }
-}
-
-impl TrafficLight {
-    fn new(color: TrafficLightColor, window_has_focus: bool) -> Self {
-        Self {
-            color,
-            window_has_focus,
-        }
-    }
-}
-
-#[derive(RenderOnce)]
-pub struct TrafficLights {
-    window_has_focus: bool,
-}
-
-impl<V: 'static> Component<V> for TrafficLights {
-    type Rendered = Div<V>;
-
-    fn render(self, view: &mut V, cx: &mut ViewContext<V>) -> Self::Rendered {
-        div()
-            .flex()
-            .items_center()
-            .gap_2()
-            .child(TrafficLight::new(
-                TrafficLightColor::Red,
-                self.window_has_focus,
-            ))
-            .child(TrafficLight::new(
-                TrafficLightColor::Yellow,
-                self.window_has_focus,
-            ))
-            .child(TrafficLight::new(
-                TrafficLightColor::Green,
-                self.window_has_focus,
-            ))
-    }
-}
-
-impl TrafficLights {
-    pub fn new() -> Self {
-        Self {
-            window_has_focus: true,
-        }
-    }
-
-    pub fn window_has_focus(mut self, window_has_focus: bool) -> Self {
-        self.window_has_focus = window_has_focus;
-        self
-    }
-}
-
-use gpui::{Div, RenderOnce};
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use gpui::{Div, Render};
-
-    use crate::Story;
-
-    use super::*;
-
-    pub struct TrafficLightsStory;
-
-    impl Render<Self> for TrafficLightsStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            Story::container(cx)
-                .child(Story::title_for::<_, TrafficLights>(cx))
-                .child(Story::label(cx, "Default"))
-                .child(TrafficLights::new())
-                .child(Story::label(cx, "Unfocused"))
-                .child(TrafficLights::new().window_has_focus(false))
-        }
-    }
-}

crates/ui2/src/to_extract/workspace.rs

@@ -1,398 +0,0 @@
-use std::sync::Arc;
-
-use chrono::DateTime;
-use gpui::{px, relative, Div, Render, RenderOnce, Size, View, VisualContext};
-use settings2::Settings;
-use theme2::ThemeSettings;
-
-use crate::prelude::*;
-use crate::{
-    static_livestream, v_stack, AssistantPanel, Button, ChatMessage, ChatPanel, Checkbox,
-    CollabPanel, EditorPane, Label, LanguageSelector, NotificationsPanel, Pane, PaneGroup, Panel,
-    PanelAllowedSides, PanelSide, ProjectPanel, SplitDirection, StatusBar, Terminal, TitleBar,
-    Toast, ToastOrigin,
-};
-
-#[derive(Clone)]
-pub struct Gpui2UiDebug {
-    pub in_livestream: bool,
-    pub enable_user_settings: bool,
-    pub show_toast: bool,
-}
-
-impl Default for Gpui2UiDebug {
-    fn default() -> Self {
-        Self {
-            in_livestream: false,
-            enable_user_settings: false,
-            show_toast: false,
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct Workspace {
-    title_bar: View<TitleBar>,
-    editor_1: View<EditorPane>,
-    show_project_panel: bool,
-    show_collab_panel: bool,
-    show_chat_panel: bool,
-    show_assistant_panel: bool,
-    show_notifications_panel: bool,
-    show_terminal: bool,
-    show_debug: bool,
-    show_language_selector: bool,
-    test_checkbox_selection: Selection,
-    debug: Gpui2UiDebug,
-}
-
-impl Workspace {
-    pub fn new(cx: &mut ViewContext<Self>) -> Self {
-        Self {
-            title_bar: TitleBar::view(cx, None),
-            editor_1: EditorPane::view(cx),
-            show_project_panel: true,
-            show_collab_panel: false,
-            show_chat_panel: false,
-            show_assistant_panel: false,
-            show_terminal: true,
-            show_language_selector: false,
-            show_debug: false,
-            show_notifications_panel: true,
-            test_checkbox_selection: Selection::Unselected,
-            debug: Gpui2UiDebug::default(),
-        }
-    }
-
-    pub fn is_project_panel_open(&self) -> bool {
-        self.show_project_panel
-    }
-
-    pub fn toggle_project_panel(&mut self, cx: &mut ViewContext<Self>) {
-        self.show_project_panel = !self.show_project_panel;
-
-        self.show_collab_panel = false;
-
-        cx.notify();
-    }
-
-    pub fn is_collab_panel_open(&self) -> bool {
-        self.show_collab_panel
-    }
-
-    pub fn toggle_collab_panel(&mut self) {
-        self.show_collab_panel = !self.show_collab_panel;
-
-        self.show_project_panel = false;
-    }
-
-    pub fn is_terminal_open(&self) -> bool {
-        self.show_terminal
-    }
-
-    pub fn toggle_terminal(&mut self, cx: &mut ViewContext<Self>) {
-        self.show_terminal = !self.show_terminal;
-
-        cx.notify();
-    }
-
-    pub fn is_chat_panel_open(&self) -> bool {
-        self.show_chat_panel
-    }
-
-    pub fn toggle_chat_panel(&mut self, cx: &mut ViewContext<Self>) {
-        self.show_chat_panel = !self.show_chat_panel;
-
-        self.show_assistant_panel = false;
-        self.show_notifications_panel = false;
-
-        cx.notify();
-    }
-
-    pub fn is_notifications_panel_open(&self) -> bool {
-        self.show_notifications_panel
-    }
-
-    pub fn toggle_notifications_panel(&mut self, cx: &mut ViewContext<Self>) {
-        self.show_notifications_panel = !self.show_notifications_panel;
-
-        self.show_chat_panel = false;
-        self.show_assistant_panel = false;
-
-        cx.notify();
-    }
-
-    pub fn is_assistant_panel_open(&self) -> bool {
-        self.show_assistant_panel
-    }
-
-    pub fn toggle_assistant_panel(&mut self, cx: &mut ViewContext<Self>) {
-        self.show_assistant_panel = !self.show_assistant_panel;
-
-        self.show_chat_panel = false;
-        self.show_notifications_panel = false;
-
-        cx.notify();
-    }
-
-    pub fn is_language_selector_open(&self) -> bool {
-        self.show_language_selector
-    }
-
-    pub fn toggle_language_selector(&mut self, cx: &mut ViewContext<Self>) {
-        self.show_language_selector = !self.show_language_selector;
-
-        cx.notify();
-    }
-
-    pub fn toggle_debug(&mut self, cx: &mut ViewContext<Self>) {
-        self.show_debug = !self.show_debug;
-
-        cx.notify();
-    }
-
-    pub fn debug_toggle_user_settings(&mut self, cx: &mut ViewContext<Self>) {
-        self.debug.enable_user_settings = !self.debug.enable_user_settings;
-
-        let mut theme_settings = ThemeSettings::get_global(cx).clone();
-
-        if self.debug.enable_user_settings {
-            theme_settings.ui_font_size = 18.0.into();
-        } else {
-            theme_settings.ui_font_size = 16.0.into();
-        }
-
-        ThemeSettings::override_global(theme_settings.clone(), cx);
-
-        cx.set_rem_size(theme_settings.ui_font_size);
-
-        cx.notify();
-    }
-
-    pub fn debug_toggle_livestream(&mut self, cx: &mut ViewContext<Self>) {
-        self.debug.in_livestream = !self.debug.in_livestream;
-
-        self.title_bar = TitleBar::view(
-            cx,
-            Some(static_livestream()).filter(|_| self.debug.in_livestream),
-        );
-
-        cx.notify();
-    }
-
-    pub fn debug_toggle_toast(&mut self, cx: &mut ViewContext<Self>) {
-        self.debug.show_toast = !self.debug.show_toast;
-
-        cx.notify();
-    }
-
-    pub fn view(cx: &mut WindowContext) -> View<Self> {
-        cx.build_view(|cx| Self::new(cx))
-    }
-}
-
-impl Render<Self> for Workspace {
-    type Element = Div<Self>;
-
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Div<Self> {
-        let root_group = PaneGroup::new_panes(
-            vec![Pane::new(
-                "pane-0",
-                Size {
-                    width: relative(1.).into(),
-                    height: relative(1.).into(),
-                },
-            )
-            .child(self.editor_1.clone())],
-            SplitDirection::Horizontal,
-        );
-        let ui_font = ThemeSettings::get_global(cx).ui_font.family.clone();
-
-        div()
-            .relative()
-            .size_full()
-            .flex()
-            .flex_col()
-            .font(ui_font)
-            .gap_0()
-            .justify_start()
-            .items_start()
-            .text_color(cx.theme().colors().text)
-            .bg(cx.theme().colors().background)
-            .child(self.title_bar.clone())
-            .child(
-                div()
-                    .absolute()
-                    .top_12()
-                    .left_12()
-                    .z_index(99)
-                    .bg(cx.theme().colors().background)
-                    .child(
-                        Checkbox::new("test_checkbox", self.test_checkbox_selection).on_click(
-                            |selection, workspace: &mut Workspace, cx| {
-                                workspace.test_checkbox_selection = selection;
-
-                                cx.notify();
-                            },
-                        ),
-                    ),
-            )
-            .child(
-                div()
-                    .flex_1()
-                    .w_full()
-                    .flex()
-                    .flex_row()
-                    .overflow_hidden()
-                    .border_t()
-                    .border_b()
-                    .border_color(cx.theme().colors().border)
-                    .children(
-                        Some(
-                            Panel::new("project-panel-outer", cx)
-                                .side(PanelSide::Left)
-                                .child(ProjectPanel::new("project-panel-inner")),
-                        )
-                        .filter(|_| self.is_project_panel_open()),
-                    )
-                    .children(
-                        Some(
-                            Panel::new("collab-panel-outer", cx)
-                                .child(CollabPanel::new("collab-panel-inner"))
-                                .side(PanelSide::Left),
-                        )
-                        .filter(|_| self.is_collab_panel_open()),
-                    )
-                    // .child(NotificationToast::new(
-                    //     "maxbrunsfeld has requested to add you as a contact.".into(),
-                    // ))
-                    .child(
-                        v_stack()
-                            .flex_1()
-                            .h_full()
-                            .child(div().flex().flex_1().child(root_group))
-                            .children(
-                                Some(
-                                    Panel::new("terminal-panel", cx)
-                                        .child(Terminal::new())
-                                        .allowed_sides(PanelAllowedSides::BottomOnly)
-                                        .side(PanelSide::Bottom),
-                                )
-                                .filter(|_| self.is_terminal_open()),
-                            ),
-                    )
-                    .children(
-                        Some(
-                            Panel::new("chat-panel-outer", cx)
-                                .side(PanelSide::Right)
-                                .child(ChatPanel::new("chat-panel-inner").messages(vec![
-                                    ChatMessage::new(
-                                        "osiewicz".to_string(),
-                                        "is this thing on?".to_string(),
-                                        DateTime::parse_from_rfc3339("2023-09-27T15:40:52.707Z")
-                                            .unwrap()
-                                            .naive_local(),
-                                    ),
-                                    ChatMessage::new(
-                                        "maxdeviant".to_string(),
-                                        "Reading you loud and clear!".to_string(),
-                                        DateTime::parse_from_rfc3339("2023-09-28T15:40:52.707Z")
-                                            .unwrap()
-                                            .naive_local(),
-                                    ),
-                                ])),
-                        )
-                        .filter(|_| self.is_chat_panel_open()),
-                    )
-                    .children(
-                        Some(
-                            Panel::new("notifications-panel-outer", cx)
-                                .side(PanelSide::Right)
-                                .child(NotificationsPanel::new("notifications-panel-inner")),
-                        )
-                        .filter(|_| self.is_notifications_panel_open()),
-                    )
-                    .children(
-                        Some(
-                            Panel::new("assistant-panel-outer", cx)
-                                .child(AssistantPanel::new("assistant-panel-inner")),
-                        )
-                        .filter(|_| self.is_assistant_panel_open()),
-                    ),
-            )
-            .child(StatusBar::new())
-            .when(self.debug.show_toast, |this| {
-                this.child(Toast::new(ToastOrigin::Bottom).child(Label::new("A toast")))
-            })
-            .children(
-                Some(
-                    div()
-                        .absolute()
-                        .top(px(50.))
-                        .left(px(640.))
-                        .z_index(8)
-                        .child(LanguageSelector::new("language-selector")),
-                )
-                .filter(|_| self.is_language_selector_open()),
-            )
-            .z_index(8)
-            // Debug
-            .child(
-                v_stack()
-                    .z_index(9)
-                    .absolute()
-                    .top_20()
-                    .left_1_4()
-                    .w_40()
-                    .gap_2()
-                    .when(self.show_debug, |this| {
-                        this.child(Button::<Workspace>::new("Toggle User Settings").on_click(
-                            Arc::new(|workspace, cx| workspace.debug_toggle_user_settings(cx)),
-                        ))
-                        .child(
-                            Button::<Workspace>::new("Toggle Toasts").on_click(Arc::new(
-                                |workspace, cx| workspace.debug_toggle_toast(cx),
-                            )),
-                        )
-                        .child(
-                            Button::<Workspace>::new("Toggle Livestream").on_click(Arc::new(
-                                |workspace, cx| workspace.debug_toggle_livestream(cx),
-                            )),
-                        )
-                    })
-                    .child(
-                        Button::<Workspace>::new("Toggle Debug")
-                            .on_click(Arc::new(|workspace, cx| workspace.toggle_debug(cx))),
-                    ),
-            )
-    }
-}
-
-#[cfg(feature = "stories")]
-pub use stories::*;
-
-#[cfg(feature = "stories")]
-mod stories {
-    use super::*;
-    use gpui::VisualContext;
-
-    pub struct WorkspaceStory {
-        workspace: View<Workspace>,
-    }
-
-    impl WorkspaceStory {
-        pub fn view(cx: &mut WindowContext) -> View<Self> {
-            cx.build_view(|cx| Self {
-                workspace: Workspace::view(cx),
-            })
-        }
-    }
-
-    impl Render<Self> for WorkspaceStory {
-        type Element = Div<Self>;
-
-        fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-            div().child(self.workspace.clone())
-        }
-    }
-}