From e2d88ab007711f54f5f33e133dcd0ade59ce6219 Mon Sep 17 00:00:00 2001
From: Nathan Sobo <nathan@zed.dev>
Date: Thu, 10 Aug 2023 10:34:31 -0600
Subject: [PATCH] Relax bounds on View type parameter

This will allow elements to work with non-views.
---
 crates/collab_ui/src/collab_titlebar_item.rs  |    2 +-
 crates/collab_ui/src/notifications.rs         |    5 +-
 crates/diagnostics/src/diagnostics.rs         |    4 +-
 crates/drag_and_drop/src/drag_and_drop.rs     |   14 +-
 crates/editor/src/items.rs                    |    2 +-
 crates/feedback/src/feedback_editor.rs        |    2 +-
 crates/gpui/playground/src/playground.rs      |   63 +
 .../playground/ui/src/editor_layout_demo.rs   |  165 ++
 crates/gpui/playground/ui/src/frame.rs        | 1565 +++++++++++++++++
 .../gpui/playground/ui/src/playground_ui.rs   |  200 +++
 crates/gpui/src/app.rs                        |  208 ++-
 crates/gpui/src/app/window.rs                 |   15 +-
 crates/gpui/src/elements.rs                   |   29 +-
 crates/gpui/src/elements/align.rs             |    8 +-
 crates/gpui/src/elements/canvas.rs            |    5 +-
 crates/gpui/src/elements/clipped.rs           |    8 +-
 crates/gpui/src/elements/constrained_box.rs   |   12 +-
 crates/gpui/src/elements/container.rs         |    9 +-
 crates/gpui/src/elements/empty.rs             |    4 +-
 crates/gpui/src/elements/expanded.rs          |    8 +-
 crates/gpui/src/elements/flex.rs              |   16 +-
 crates/gpui/src/elements/hook.rs              |    9 +-
 crates/gpui/src/elements/image.rs             |    4 +-
 crates/gpui/src/elements/keystroke_label.rs   |    2 +-
 crates/gpui/src/elements/label.rs             |    4 +-
 crates/gpui/src/elements/list.rs              |   32 +-
 .../gpui/src/elements/mouse_event_handler.rs  |    8 +-
 crates/gpui/src/elements/overlay.rs           |    8 +-
 crates/gpui/src/elements/resizable.rs         |    8 +-
 crates/gpui/src/elements/stack.rs             |   13 +-
 crates/gpui/src/elements/svg.rs               |    6 +-
 crates/gpui/src/elements/text.rs              |    4 +-
 crates/gpui/src/elements/tooltip.rs           |   10 +-
 crates/gpui/src/elements/uniform_list.rs      |   11 +-
 crates/gpui/src/scene/mouse_region.rs         |   46 +-
 crates/language_tools/src/lsp_log.rs          |    2 +-
 crates/language_tools/src/syntax_tree_view.rs |    2 +-
 crates/project_panel/src/project_panel.rs     |    2 +-
 .../src/highlighted_workspace_location.rs     |    4 +-
 crates/search/src/project_search.rs           |    2 +-
 crates/terminal_view/src/terminal_view.rs     |    2 +-
 crates/theme/src/ui.rs                        |   16 +-
 crates/welcome/src/welcome.rs                 |    2 +-
 crates/workspace/src/item.rs                  |    4 +-
 crates/workspace/src/pane.rs                  |    6 +-
 .../src/pane/dragged_item_receiver.rs         |    4 +-
 crates/workspace/src/shared_screen.rs         |    2 +-
 47 files changed, 2271 insertions(+), 286 deletions(-)
 create mode 100644 crates/gpui/playground/src/playground.rs
 create mode 100644 crates/gpui/playground/ui/src/editor_layout_demo.rs
 create mode 100644 crates/gpui/playground/ui/src/frame.rs
 create mode 100644 crates/gpui/playground/ui/src/playground_ui.rs

diff --git a/crates/collab_ui/src/collab_titlebar_item.rs b/crates/collab_ui/src/collab_titlebar_item.rs
index dbcbaf6072..eadc322165 100644
--- a/crates/collab_ui/src/collab_titlebar_item.rs
+++ b/crates/collab_ui/src/collab_titlebar_item.rs
@@ -1218,7 +1218,7 @@ impl CollabTitlebarItem {
         style
     }
 
-    fn render_face<V: View>(
+    fn render_face<V: 'static>(
         avatar: Arc<ImageData>,
         avatar_style: AvatarStyle,
         background_color: Color,
diff --git a/crates/collab_ui/src/notifications.rs b/crates/collab_ui/src/notifications.rs
index cbd072fe89..d38258ce63 100644
--- a/crates/collab_ui/src/notifications.rs
+++ b/crates/collab_ui/src/notifications.rs
@@ -2,14 +2,14 @@ use client::User;
 use gpui::{
     elements::*,
     platform::{CursorStyle, MouseButton},
-    AnyElement, Element, View, ViewContext,
+    AnyElement, Element, ViewContext,
 };
 use std::sync::Arc;
 
 enum Dismiss {}
 enum Button {}
 
-pub fn render_user_notification<F, V>(
+pub fn render_user_notification<F, V: 'static>(
     user: Arc<User>,
     title: &'static str,
     body: Option<&'static str>,
@@ -19,7 +19,6 @@ pub fn render_user_notification<F, V>(
 ) -> AnyElement<V>
 where
     F: 'static + Fn(&mut V, &mut ViewContext<V>),
-    V: View,
 {
     let theme = theme::current(cx).clone();
     let theme = &theme.contact_notification;
diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs
index 16a7340fae..0e5b714f09 100644
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -538,7 +538,7 @@ impl ProjectDiagnosticsEditor {
 }
 
 impl Item for ProjectDiagnosticsEditor {
-    fn tab_content<T: View>(
+    fn tab_content<T: 'static>(
         &self,
         _detail: Option<usize>,
         style: &theme::Tab,
@@ -735,7 +735,7 @@ fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
     })
 }
 
-pub(crate) fn render_summary<T: View>(
+pub(crate) fn render_summary<T: 'static>(
     summary: &DiagnosticSummary,
     text_style: &TextStyle,
     theme: &theme::ProjectDiagnostics,
diff --git a/crates/drag_and_drop/src/drag_and_drop.rs b/crates/drag_and_drop/src/drag_and_drop.rs
index ddfed0c858..28b876504c 100644
--- a/crates/drag_and_drop/src/drag_and_drop.rs
+++ b/crates/drag_and_drop/src/drag_and_drop.rs
@@ -11,7 +11,7 @@ use gpui::{
 
 const DEAD_ZONE: f32 = 4.;
 
-enum State<V: View> {
+enum State<V> {
     Down {
         region_offset: Vector2F,
         region: RectF,
@@ -31,7 +31,7 @@ enum State<V: View> {
     Canceled,
 }
 
-impl<V: View> Clone for State<V> {
+impl<V> Clone for State<V> {
     fn clone(&self) -> Self {
         match self {
             &State::Down {
@@ -68,12 +68,12 @@ impl<V: View> Clone for State<V> {
     }
 }
 
-pub struct DragAndDrop<V: View> {
+pub struct DragAndDrop<V> {
     containers: HashSet<WeakViewHandle<V>>,
     currently_dragged: Option<State<V>>,
 }
 
-impl<V: View> Default for DragAndDrop<V> {
+impl<V> Default for DragAndDrop<V> {
     fn default() -> Self {
         Self {
             containers: Default::default(),
@@ -82,7 +82,7 @@ impl<V: View> Default for DragAndDrop<V> {
     }
 }
 
-impl<V: View> DragAndDrop<V> {
+impl<V: 'static> DragAndDrop<V> {
     pub fn register_container(&mut self, handle: WeakViewHandle<V>) {
         self.containers.insert(handle);
     }
@@ -291,7 +291,7 @@ impl<V: View> DragAndDrop<V> {
     }
 }
 
-pub trait Draggable<V: View> {
+pub trait Draggable<V> {
     fn as_draggable<D: View, P: Any>(
         self,
         payload: P,
@@ -301,7 +301,7 @@ pub trait Draggable<V: View> {
         Self: Sized;
 }
 
-impl<Tag, V: View> Draggable<V> for MouseEventHandler<Tag, V> {
+impl<Tag, V: 'static> Draggable<V> for MouseEventHandler<Tag, V> {
     fn as_draggable<D: View, P: Any>(
         self,
         payload: P,
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index b99977a60e..b98b54fe44 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -561,7 +561,7 @@ impl Item for Editor {
         }
     }
 
-    fn tab_content<T: View>(
+    fn tab_content<T: 'static>(
         &self,
         detail: Option<usize>,
         style: &theme::Tab,
diff --git a/crates/feedback/src/feedback_editor.rs b/crates/feedback/src/feedback_editor.rs
index 47cb90875a..a717223f6d 100644
--- a/crates/feedback/src/feedback_editor.rs
+++ b/crates/feedback/src/feedback_editor.rs
@@ -268,7 +268,7 @@ impl Item for FeedbackEditor {
         Some("Send Feedback".into())
     }
 
-    fn tab_content<T: View>(
+    fn tab_content<T: 'static>(
         &self,
         _: Option<usize>,
         style: &theme::Tab,
diff --git a/crates/gpui/playground/src/playground.rs b/crates/gpui/playground/src/playground.rs
new file mode 100644
index 0000000000..e65277cf03
--- /dev/null
+++ b/crates/gpui/playground/src/playground.rs
@@ -0,0 +1,63 @@
+use gpui::{
+    platform::{TitlebarOptions, WindowOptions},
+    AnyElement, Element, Entity, View,
+};
+use log::LevelFilter;
+use simplelog::SimpleLogger;
+use std::ops::{Deref, DerefMut};
+
+// dymod! {
+//     #[path = "../ui/src/playground_ui.rs"]
+//     pub mod ui {
+//         // fn workspace<V>(theme: &ThemeColors) -> impl Element<V>;
+//     }
+// }
+
+fn main() {
+    SimpleLogger::init(LevelFilter::Info, Default::default()).expect("could not initialize logger");
+
+    gpui::App::new(()).unwrap().run(|cx| {
+        cx.platform().activate(true);
+        cx.add_window(
+            WindowOptions {
+                titlebar: Some(TitlebarOptions {
+                    appears_transparent: true,
+                    ..Default::default()
+                }),
+                ..Default::default()
+            },
+            |_| Playground::default(),
+        );
+    });
+}
+
+#[derive(Clone, Default)]
+struct Playground(playground_ui::Playground<Self>);
+
+impl Deref for Playground {
+    type Target = playground_ui::Playground<Self>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for Playground {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl Entity for Playground {
+    type Event = ();
+}
+
+impl View for Playground {
+    fn ui_name() -> &'static str {
+        "PlaygroundView"
+    }
+
+    fn render(&mut self, _: &mut gpui::ViewContext<Self>) -> AnyElement<Playground> {
+        self.0.clone().into_any()
+    }
+}
diff --git a/crates/gpui/playground/ui/src/editor_layout_demo.rs b/crates/gpui/playground/ui/src/editor_layout_demo.rs
new file mode 100644
index 0000000000..c51ca0ba92
--- /dev/null
+++ b/crates/gpui/playground/ui/src/editor_layout_demo.rs
@@ -0,0 +1,165 @@
+use gpui::{AnyElement, Element, LayoutContext, View, ViewContext};
+
+#[derive(Element, Clone, Default)]
+pub struct Playground<V>(PhantomData<V>);
+
+// example layout design here: https://www.figma.com/file/5QLTmxjO0xQpDD3CD4hR6T/Untitled?type=design&node-id=0%3A1&mode=design&t=SoJieVVIvDDDKagv-1
+
+impl<V> Playground<V> {
+    pub fn render(&mut self, _: &mut V, _: &mut gpui::ViewContext<V>) -> impl Element<V> {
+        col() // fullscreen container with header and main in it
+            .width(flex(1.))
+            .height(flex(1.))
+            .fill(colors(gray.900))
+            .children([
+                row() // header container
+                    .fill(colors(gray.900))
+                    .width(flex(1.))
+                    .children([
+                        row() // tab bar
+                            .width(flex(1.))
+                            .gap(spacing(2))
+                            .padding(spacing(3))
+                            .overflow_x(scroll())
+                            .chidren([
+                                row() // tab
+                                    .padding_x(spacing(3))
+                                    .padding_y(spacing(2))
+                                    .corner_radius(6.)
+                                    .gap(spacing(3))
+                                    .align(center())
+                                    .fill(colors(gray.800))
+                                    .children([text("Tab title 1"), svg("icon_name")]),
+                                row() // tab
+                                    .padding_x(spacing(3))
+                                    .padding_y(spacing(2))
+                                    .corner_radius(6.)
+                                    .gap(spacing(3))
+                                    .align(center())
+                                    .fill(colors(gray.800))
+                                    .children([text("Tab title 2"), svg("icon_name")]),
+                                row() // tab
+                                    .padding_x(spacing(3))
+                                    .padding_y(spacing(2))
+                                    .corner_radius(6.)
+                                    .gap(spacing(3))
+                                    .align(center())
+                                    .fill(colors(gray.800))
+                                    .children([text("Tab title 3"), svg("icon_name")]),
+                            ]),
+                        row() // tab bar actions
+                            .border_left(colors(gray.700))
+                            .gap(spacing(2))
+                            .padding(spacing(3))
+                            .chidren([
+                                row()
+                                    .width(spacing(8))
+                                    .height(spacing(8))
+                                    .corner_radius(6.)
+                                    .justify(center())
+                                    .align(center())
+                                    .fill(colors(gray.800))
+                                    .child(svg(icon_name)),
+                                row()
+                                    .width(spacing(8))
+                                    .height(spacing(8))
+                                    .corner_radius(6.)
+                                    .justify(center())
+                                    .align(center())
+                                    .fill(colors(gray.800))
+                                    .child(svg(icon_name)),
+                                row()
+                                    .width(spacing(8))
+                                    .height(spacing(8))
+                                    .corner_radius(6.)
+                                    .justify(center())
+                                    .align(center())
+                                    .fill(colors(gray.800))
+                                    .child(svg(icon_name)),
+                            ]),
+                    ]),
+                row() // main container
+                    .width(flex(1.))
+                    .height(flex(1.))
+                    .children([
+                        col() // left sidebar
+                            .fill(colors(gray.800))
+                            .border_right(colors(gray.700))
+                            .height(flex(1.))
+                            .width(260.)
+                            .children([
+                                col() // containter to hold list items and notification alert box
+                                    .justify(between())
+                                    .padding_x(spacing(6))
+                                    .padding_bottom(3)
+                                    .padding_top(spacing(6))
+                                    .children([
+                                        col().gap(spacing(3)).children([ // sidebar list
+                                            text("Item"),
+                                            text("Item"),
+                                            text("Item"),
+                                            text("Item"),
+                                            text("Item"),
+                                            text("Item"),
+                                            text("Item"),
+                                            text("Item"),
+                                        ]),
+                                        col().align(center()).gap(spacing(1)).children([ // notification alert box
+                                            text("Title text").size("lg"),
+                                            text("Description text goes here")
+                                                .text_color(colors(rose.200)),
+                                        ]),
+                                    ]),
+                                row()
+                                    .padding_x(spacing(3))
+                                    .padding_y(spacing(2))
+                                    .border_top(1., colors(gray.700))
+                                    .align(center())
+                                    .gap(spacing(2))
+                                    .fill(colors(gray.900))
+                                    .children([
+                                        row() // avatar container
+                                            .width(spacing(8))
+                                            .height(spacing(8))
+                                            .corner_radius(spacing(8))
+                                            .justify(center())
+                                            .align(center())
+                                            .child(image(image_url)),
+                                        text("FirstName Lastname"), // user name
+                                    ]),
+                            ]),
+                        col() // primary content container
+                            .align(center())
+                            .justify(center())
+                            .child(
+                                col().justify(center()).gap(spacing(8)).children([ // detail container wrapper for center positioning
+                                    col() // blue rectangle
+                                        .width(rem(30.))
+                                        .height(rem(20.))
+                                        .corner_radius(16.)
+                                        .fill(colors(blue.200)),
+                                    col().gap(spacing(1)).children([ // center content text items
+                                        text("This is a title").size("lg"),
+                                        text("This is a description").text_color(colors(gray.500)),
+                                    ]),
+                                ]),
+                            ),
+                        col(), // right sidebar
+                    ]),
+            ])
+    }
+}
+
+// row(
+//     padding(),
+//     width(),
+//     fill(),
+// )
+
+// .width(flex(1.))
+// .height(flex(1.))
+// .justify(end())
+// .align(start()) // default
+// .fill(green)
+// .child(other_tab_bar())
+// .child(profile_menu())
diff --git a/crates/gpui/playground/ui/src/frame.rs b/crates/gpui/playground/ui/src/frame.rs
new file mode 100644
index 0000000000..6f33613578
--- /dev/null
+++ b/crates/gpui/playground/ui/src/frame.rs
@@ -0,0 +1,1565 @@
+#![allow(unused_variables, dead_code)]
+
+use derive_more::{Add, Deref, DerefMut};
+use gpui::elements::layout_highlighted_chunks;
+use gpui::Entity;
+use gpui::{
+    color::Color,
+    fonts::HighlightStyle,
+    geometry::{
+        rect::RectF,
+        vector::{vec2f, Vector2F},
+    },
+    json::{json, ToJson},
+    scene,
+    serde_json::Value,
+    text_layout::{Line, ShapedBoundary},
+    AnyElement, AppContext, Element, LayoutContext, PaintContext, Quad, SceneBuilder,
+    SizeConstraint, View, ViewContext,
+};
+use length::{Length, Rems};
+use log::warn;
+use optional_struct::*;
+use std::{any::Any, borrow::Cow, f32, ops::Range, sync::Arc};
+
+use crate::color::Rgba;
+
+pub struct Frame<V> {
+    style: FrameStyle,
+    children: Vec<AnyElement<V>>,
+    id: Option<Cow<'static, str>>,
+    before_paint: Option<Box<dyn FnMut(RectF, &mut FrameLayout, &mut PaintContext<V>)>>,
+}
+
+pub fn column<V>() -> Frame<V> {
+    Frame::default()
+}
+
+pub fn row<V>() -> Frame<V> {
+    Frame {
+        style: FrameStyle {
+            axis: Axis3d::X,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+}
+
+pub fn stack<V>() -> Frame<V> {
+    Frame {
+        style: FrameStyle {
+            axis: Axis3d::Z,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+}
+
+impl<V> Default for Frame<V> {
+    fn default() -> Self {
+        Self {
+            style: Default::default(),
+            children: Default::default(),
+            id: None,
+            before_paint: None,
+        }
+    }
+}
+
+impl<V: 'static> Element<V> for Frame<V> {
+    type LayoutState = FrameLayout;
+    type PaintState = ();
+
+    fn layout(
+        &mut self,
+        constraint: SizeConstraint,
+        view: &mut V,
+        cx: &mut LayoutContext<V>,
+    ) -> (Vector2F, Self::LayoutState) {
+        let layout = if let Some(axis) = self.style.axis.to_2d() {
+            self.layout_xy(axis, constraint, cx.rem_pixels(), view, cx)
+        } else {
+            todo!()
+        };
+        (layout.size.max(constraint.min), layout)
+    }
+
+    fn paint(
+        &mut self,
+        scene: &mut SceneBuilder,
+        bounds: RectF,
+        visible_bounds: RectF,
+        layout: &mut FrameLayout,
+        view: &mut V,
+        cx: &mut PaintContext<V>,
+    ) -> Self::PaintState {
+        if let Some(before_paint) = &mut self.before_paint {
+            before_paint(bounds, layout, cx);
+        }
+
+        let bounds_center = bounds.size() / 2.;
+        let bounds_target = bounds_center + (bounds_center * self.style.align.0);
+        let layout_center = layout.size / 2.;
+        let layout_target = layout_center + layout_center * self.style.align.0;
+        let delta = bounds_target - layout_target;
+
+        let aligned_bounds = RectF::new(bounds.origin() + delta, layout.size);
+        let margined_bounds = RectF::from_points(
+            aligned_bounds.origin() + vec2f(layout.margins.left, layout.margins.top),
+            aligned_bounds.lower_right() - vec2f(layout.margins.right, layout.margins.bottom),
+        );
+
+        // Paint drop shadow
+        for shadow in &self.style.shadows {
+            scene.push_shadow(scene::Shadow {
+                bounds: margined_bounds + shadow.offset,
+                corner_radius: self.style.corner_radius,
+                sigma: shadow.blur,
+                color: shadow.color,
+            });
+        }
+
+        // // Paint cursor style
+        // if let Some(hit_bounds) = content_bounds.intersection(visible_bounds) {
+        //     if let Some(style) = self.style.cursor {
+        //         scene.push_cursor_region(CursorRegion {
+        //             bounds: hit_bounds,
+        //             style,
+        //         });
+        //     }
+        // }
+
+        // Render the background and/or the border.
+        let Fill::Color(fill_color) = self.style.fill;
+        let is_fill_visible = fill_color.a > 0.;
+        if is_fill_visible || self.style.borders.is_visible() {
+            scene.push_quad(Quad {
+                bounds: margined_bounds,
+                background: is_fill_visible.then_some(fill_color.into()),
+                border: scene::Border {
+                    width: self.style.borders.width,
+                    color: self.style.borders.color,
+                    overlay: false,
+                    top: self.style.borders.top,
+                    right: self.style.borders.right,
+                    bottom: self.style.borders.bottom,
+                    left: self.style.borders.left,
+                },
+                corner_radius: self.style.corner_radius,
+            });
+        }
+
+        if !self.children.is_empty() {
+            // Account for padding first.
+            let borders = &self.style.borders;
+            let padded_bounds = RectF::from_points(
+                margined_bounds.origin()
+                    + vec2f(
+                        borders.left_width() + layout.padding.left,
+                        borders.top_width() + layout.padding.top,
+                    ),
+                margined_bounds.lower_right()
+                    - vec2f(
+                        layout.padding.right + borders.right_width(),
+                        layout.padding.bottom + borders.bottom_width(),
+                    ),
+            );
+
+            if let Some(axis) = self.style.axis.to_2d() {
+                // let parent_size = padded_bounds.size();
+                let mut child_origin = padded_bounds.origin();
+
+                for child in &mut self.children {
+                    child.paint(scene, child_origin, visible_bounds, view, cx);
+
+                    // Advance along the primary axis by the size of this child
+                    child_origin.set(axis, child_origin.get(axis) + child.size().get(axis));
+                }
+            } else {
+                todo!();
+            }
+        }
+    }
+
+    fn rect_for_text_range(
+        &self,
+        range_utf16: Range<usize>,
+        _: RectF,
+        _: RectF,
+        _: &Self::LayoutState,
+        _: &Self::PaintState,
+        view: &V,
+        cx: &ViewContext<V>,
+    ) -> Option<RectF> {
+        self.children
+            .iter()
+            .find_map(|child| child.rect_for_text_range(range_utf16.clone(), view, cx))
+    }
+
+    fn debug(
+        &self,
+        bounds: RectF,
+        _: &Self::LayoutState,
+        _: &Self::PaintState,
+        view: &V,
+        cx: &ViewContext<V>,
+    ) -> Value {
+        json!({
+            "type": "Frame",
+            "bounds": bounds.to_json(),
+            // TODO!
+            // "children": self.content.iter().map(|child| child.debug(view, cx)).collect::<Vec<Value>>()
+        })
+    }
+
+    fn metadata(&self) -> Option<&dyn Any> {
+        Some(&self.style)
+    }
+}
+
+impl<V: 'static> Frame<V> {
+    pub fn id(mut self, id: impl Into<Cow<'static, str>>) -> Self {
+        self.id = Some(id.into());
+        self
+    }
+
+    pub fn child(mut self, child: impl Element<V>) -> Self {
+        self.children.push(child.into_any());
+        self
+    }
+
+    pub fn children<I, E>(mut self, children: I) -> Self
+    where
+        I: IntoIterator<Item = E>,
+        E: Element<V>,
+    {
+        self.children
+            .extend(children.into_iter().map(|child| child.into_any()));
+        self
+    }
+
+    pub fn size(self, size: impl Into<Size<Length>>) -> Self {
+        let size = size.into();
+        self.width(size.width).height(size.height)
+    }
+
+    pub fn width(mut self, width: impl Into<Length>) -> Self {
+        self.style.size.width = width.into();
+        self
+    }
+
+    pub fn height(mut self, height: impl Into<Length>) -> Self {
+        self.style.size.height = height.into();
+        self
+    }
+
+    pub fn fill(mut self, fill: impl Into<Fill>) -> Self {
+        self.style.fill = fill.into();
+        self
+    }
+
+    pub fn text_size(mut self, text_size: Rems) -> Self {
+        self.style.text.size = Some(text_size);
+        self
+    }
+
+    pub fn margins(mut self, margins: impl Into<Edges<Length>>) -> Self {
+        self.style.margins = margins.into();
+        self
+    }
+
+    pub fn margin_x(mut self, margin: impl Into<Length>) -> Self {
+        self.style.margins.set_x(margin.into());
+        self
+    }
+
+    pub fn margin_y(mut self, margin: impl Into<Length>) -> Self {
+        self.style.margins.set_y(margin.into());
+        self
+    }
+
+    pub fn margin_top(mut self, top: Length) -> Self {
+        self.style.margins.top = top;
+        self
+    }
+
+    pub fn margin_bottom(mut self, bottom: Length) -> Self {
+        self.style.margins.bottom = bottom;
+        self
+    }
+
+    pub fn margin_left(mut self, left: impl Into<Length>) -> Self {
+        self.style.margins.left = left.into();
+        self
+    }
+
+    pub fn margin_right(mut self, right: impl Into<Length>) -> Self {
+        self.style.margins.right = right.into();
+        self
+    }
+
+    pub fn align(mut self, alignment: f32) -> Self {
+        let cross_axis = self
+            .style
+            .axis
+            .to_2d()
+            .map(Axis2d::rotate)
+            .unwrap_or(Axis2d::Y);
+        self.style.align.set(cross_axis, alignment);
+        self
+    }
+
+    pub fn justify(mut self, alignment: f32) -> Self {
+        let axis = self.style.axis.to_2d().unwrap_or(Axis2d::X);
+        self.style.align.set(axis, alignment);
+        self
+    }
+
+    fn id_string(&self) -> String {
+        self.id.as_deref().unwrap_or("<anonymous>").to_string()
+    }
+
+    fn layout_xy(
+        &mut self,
+        primary_axis: Axis2d,
+        constraint: SizeConstraint,
+        rem_pixels: f32,
+        view: &mut V,
+        cx: &mut LayoutContext<V>,
+    ) -> FrameLayout {
+        let cross_axis = primary_axis.rotate();
+        let total_flex = self.style.flex();
+        let mut layout = FrameLayout {
+            size: Default::default(),
+            padding: self.style.padding.fixed_pixels(rem_pixels),
+            margins: self.style.margins.fixed_pixels(rem_pixels),
+            borders: self.style.borders.edges(),
+        };
+        let fixed_padding_size = layout.padding.size();
+        let fixed_margin_size = layout.margins.size();
+        let borders_size = layout.borders.size();
+        let fixed_constraint = constraint - fixed_margin_size - borders_size - fixed_padding_size;
+
+        // Determine the child constraints in each dimension based on the styled size
+        let mut child_constraint = SizeConstraint::default();
+        for axis in [Axis2d::X, Axis2d::Y] {
+            let length = self.style.size.get(axis);
+            let content_length = match length {
+                Length::Hug => {
+                    // Tell the children not to expand
+                    0.
+                }
+                Length::Fixed(fixed_length) => {
+                    // Tell the children to expand up to the fixed length minus the padding.
+                    fixed_length.to_pixels(rem_pixels) - fixed_padding_size.get(axis)
+                }
+                Length::Auto { .. } => {
+                    // Tell the children to expand to fill their share of the flex space in this node.
+                    length.flex_pixels(
+                        rem_pixels,
+                        &mut total_flex.get(axis),
+                        &mut fixed_constraint.max.get(axis),
+                    )
+                }
+            };
+            child_constraint.max.set(axis, content_length);
+            if axis == cross_axis {
+                child_constraint.min.set(axis, content_length);
+            }
+        }
+
+        // Lay out inflexible children. Total up flex of flexible children for
+        // use in a second pass.
+        let mut remaining_length = child_constraint.max.get(primary_axis);
+        let mut remaining_flex = 0.;
+        let mut total_length = 0.;
+        let mut cross_axis_max: f32 = 0.;
+
+        for child in &mut self.children {
+            if let Some(child_flex) = child
+                .metadata::<FrameStyle>()
+                .map(|style| style.flex().get(primary_axis))
+            {
+                if child_flex > 0. {
+                    remaining_flex += child_flex;
+                    continue;
+                }
+            }
+
+            let child_size = child.layout(child_constraint, view, cx);
+            let child_length = child_size.get(primary_axis);
+            remaining_length -= child_length;
+            total_length += child_length;
+            cross_axis_max = cross_axis_max.max(child_size.get(cross_axis));
+        }
+
+        // Distribute the remaining length among the flexible children.
+        for child in &mut self.children {
+            if let Some(child_flex) = child
+                .metadata::<FrameStyle>()
+                .map(|style| style.flex().get(primary_axis))
+            {
+                if child_flex > 0. {
+                    let max_child_length = (child_flex / remaining_flex) * remaining_length;
+                    child_constraint.max.set(primary_axis, max_child_length);
+
+                    let child_size = child.layout(child_constraint, view, cx);
+                    let child_length = child_size.get(primary_axis);
+                    total_length += child_length;
+                    remaining_length -= child_length;
+                    remaining_flex -= child_flex;
+                    cross_axis_max = cross_axis_max.max(child_size.get(cross_axis));
+                }
+            }
+        }
+
+        let content_size = match primary_axis {
+            Axis2d::X => vec2f(total_length, cross_axis_max),
+            Axis2d::Y => vec2f(cross_axis_max, total_length),
+        };
+
+        // Distribute remaining space to flexible padding and margins.
+        for axis in [Axis2d::X, Axis2d::Y] {
+            let length = self.style.size.get(axis);
+            match length {
+                Length::Hug => {
+                    let mut remaining_flex = total_flex.get(axis);
+                    let mut remaining_length =
+                        fixed_constraint.min.get(axis) - content_size.get(axis);
+
+                    layout.padding.compute_flex_edges(
+                        &self.style.padding,
+                        axis,
+                        &mut remaining_flex,
+                        &mut remaining_length,
+                        rem_pixels,
+                    );
+                    layout.margins.compute_flex_edges(
+                        &self.style.margins,
+                        axis,
+                        &mut remaining_flex,
+                        &mut remaining_length,
+                        rem_pixels,
+                    );
+                    layout.size.set(
+                        axis,
+                        content_size.get(axis)
+                            + layout.padding.size().get(axis)
+                            + layout.borders.size().get(axis)
+                            + layout.margins.size().get(axis),
+                    );
+                }
+                Length::Fixed(fixed_length) => {
+                    let fixed_length = fixed_length.to_pixels(rem_pixels);
+
+                    // With a fixed length, we can only distribute the space in the fixed-length container
+                    // not consumed by the content.
+                    let mut padding_flex = self.style.padding.flex().get(axis);
+                    let mut max_padding_length = (fixed_length - content_size.get(axis)).max(0.);
+                    layout.padding.compute_flex_edges(
+                        &self.style.padding,
+                        axis,
+                        &mut padding_flex,
+                        &mut max_padding_length,
+                        rem_pixels,
+                    );
+
+                    // Similarly, distribute the available space for margins so we preserve the fixed length
+                    // of the container.
+                    let mut margin_flex = self.style.margins.flex().get(axis);
+                    let mut max_margin_length = constraint.max.get(axis) - fixed_length;
+                    layout.margins.compute_flex_edges(
+                        &self.style.margins,
+                        axis,
+                        &mut margin_flex,
+                        &mut max_margin_length,
+                        rem_pixels,
+                    );
+
+                    layout
+                        .size
+                        .set(axis, fixed_length + layout.margins.size().get(axis))
+                }
+                Length::Auto { .. } => {
+                    let mut remaining_flex = total_flex.get(axis);
+                    let mut remaining_length = fixed_constraint.max.get(axis);
+                    let flex_length =
+                        length.flex_pixels(rem_pixels, &mut remaining_flex, &mut remaining_length);
+
+                    layout.padding.compute_flex_edges(
+                        &self.style.padding,
+                        axis,
+                        &mut remaining_flex,
+                        &mut remaining_length,
+                        rem_pixels,
+                    );
+
+                    layout.margins.compute_flex_edges(
+                        &self.style.margins,
+                        axis,
+                        &mut remaining_flex,
+                        &mut remaining_length,
+                        rem_pixels,
+                    );
+
+                    layout.size.set(
+                        axis,
+                        flex_length
+                            + layout.padding.size().get(axis)
+                            + layout.borders.size().get(axis)
+                            + layout.margins.size().get(axis),
+                    )
+                }
+            }
+        }
+
+        layout
+    }
+
+    fn before_paint<H>(mut self, handler: H) -> Self
+    where
+        H: 'static + FnMut(RectF, &mut FrameLayout, &mut PaintContext<V>),
+    {
+        self.before_paint = Some(Box::new(handler));
+        self
+    }
+}
+
+pub struct TopBottom {
+    top: Length,
+    bottom: Length,
+}
+
+impl<T: Into<Length>> From<(T, T)> for TopBottom {
+    fn from((top, bottom): (T, T)) -> Self {
+        Self {
+            top: top.into(),
+            bottom: bottom.into(),
+        }
+    }
+}
+
+impl<T: Copy + Into<Length>> From<T> for TopBottom {
+    fn from(both: T) -> Self {
+        Self {
+            top: both.into(),
+            bottom: both.into(),
+        }
+    }
+}
+
+pub struct LeftRight {
+    left: Length,
+    right: Length,
+}
+
+impl From<(Length, Length)> for LeftRight {
+    fn from((left, right): (Length, Length)) -> Self {
+        Self { left, right }
+    }
+}
+
+impl From<Length> for LeftRight {
+    fn from(both: Length) -> Self {
+        Self {
+            left: both,
+            right: both,
+        }
+    }
+}
+
+struct Interactive<Style> {
+    default: Style,
+    hovered: Style,
+    active: Style,
+    disabled: Style,
+}
+
+#[derive(Clone, Default)]
+pub struct FrameStyle {
+    axis: Axis3d,
+    wrap: bool,
+    align: Alignment,
+    overflow_x: Overflow,
+    overflow_y: Overflow,
+    gap_x: Gap,
+    gap_y: Gap,
+
+    size: Size<Length>,
+    margins: Edges<Length>,
+    padding: Edges<Length>,
+    text: OptionalTextStyle,
+    opacity: f32,
+    fill: Fill,
+    borders: Borders,
+    corner_radius: f32,
+    shadows: Vec<Shadow>,
+}
+
+impl FrameStyle {
+    fn flex(&self) -> Vector2F {
+        self.size.flex() + self.padding.flex() + self.margins.flex()
+    }
+}
+
+#[optional_struct]
+struct TextStyle {
+    size: Rems,
+    font_family: Arc<str>,
+    weight: FontWeight,
+    style: FontStyle,
+}
+
+#[derive(Add, Default, Clone)]
+pub struct Size<T> {
+    width: T,
+    height: T,
+}
+
+impl<T: Copy> Size<T> {
+    fn get(&self, axis: Axis2d) -> T {
+        match axis {
+            Axis2d::X => self.width,
+            Axis2d::Y => self.height,
+        }
+    }
+}
+
+impl Size<Length> {
+    fn fixed_pixels(&self, rem_pixels: f32) -> Size<f32> {
+        Size {
+            width: self.width.fixed_pixels(rem_pixels),
+            height: self.height.fixed_pixels(rem_pixels),
+        }
+    }
+
+    pub fn fixed(&self) -> Size<Rems> {
+        Size {
+            width: self.width.fixed().unwrap_or_default(),
+            height: self.height.fixed().unwrap_or_default(),
+        }
+    }
+
+    pub fn flex(&self) -> Vector2F {
+        vec2f(
+            self.width.flex().unwrap_or(0.),
+            self.height.flex().unwrap_or(0.),
+        )
+    }
+}
+
+impl Size<Rems> {
+    pub fn to_pixels(&self, rem_size: f32) -> Vector2F {
+        vec2f(
+            self.width.to_pixels(rem_size),
+            self.height.to_pixels(rem_size),
+        )
+    }
+}
+
+impl From<Length> for Size<Length> {
+    fn from(value: Length) -> Self {
+        Self {
+            width: value,
+            height: value,
+        }
+    }
+}
+
+#[derive(Clone, Default, Debug)]
+pub struct Edges<T> {
+    top: T,
+    bottom: T,
+    left: T,
+    right: T,
+}
+
+impl<T> Edges<T> {
+    fn start(&self, axis: Axis2d) -> &T {
+        match axis {
+            Axis2d::X => &self.left,
+            Axis2d::Y => &self.top,
+        }
+    }
+
+    fn start_mut(&mut self, axis: Axis2d) -> &mut T {
+        match axis {
+            Axis2d::X => &mut self.left,
+            Axis2d::Y => &mut self.top,
+        }
+    }
+
+    fn end(&self, axis: Axis2d) -> &T {
+        match axis {
+            Axis2d::X => &self.right,
+            Axis2d::Y => &self.bottom,
+        }
+    }
+
+    fn end_mut(&mut self, axis: Axis2d) -> &mut T {
+        match axis {
+            Axis2d::X => &mut self.right,
+            Axis2d::Y => &mut self.bottom,
+        }
+    }
+}
+
+impl<T: Clone> Edges<T> {
+    pub fn set_x(&mut self, value: T) {
+        self.left = value.clone();
+        self.right = value
+    }
+
+    pub fn set_y(&mut self, value: T) {
+        self.top = value.clone();
+        self.bottom = value
+    }
+}
+
+impl Edges<f32> {
+    fn size(&self) -> Vector2F {
+        vec2f(self.left + self.right, self.top + self.bottom)
+    }
+
+    fn compute_flex_edges(
+        &mut self,
+        style_edges: &Edges<Length>,
+        axis: Axis2d,
+        remaining_flex: &mut f32,
+        remaining_length: &mut f32,
+        rem_pixels: f32,
+    ) {
+        *self.start_mut(axis) +=
+            style_edges
+                .start(axis)
+                .flex_pixels(rem_pixels, remaining_flex, remaining_length);
+        *self.end_mut(axis) +=
+            style_edges
+                .end(axis)
+                .flex_pixels(rem_pixels, remaining_flex, remaining_length);
+    }
+}
+
+impl Edges<Length> {
+    fn fixed_pixels(&self, rem_pixels: f32) -> Edges<f32> {
+        Edges {
+            top: self.top.fixed_pixels(rem_pixels),
+            bottom: self.bottom.fixed_pixels(rem_pixels),
+            left: self.left.fixed_pixels(rem_pixels),
+            right: self.right.fixed_pixels(rem_pixels),
+        }
+    }
+
+    fn flex_pixels(
+        &self,
+        rem_pixels: f32,
+        remaining_flex: &mut f32,
+        remaining_length: &mut f32,
+    ) -> Edges<f32> {
+        Edges {
+            top: self
+                .top
+                .flex_pixels(rem_pixels, remaining_flex, remaining_length),
+            bottom: self
+                .bottom
+                .flex_pixels(rem_pixels, remaining_flex, remaining_length),
+            left: self
+                .left
+                .flex_pixels(rem_pixels, remaining_flex, remaining_length),
+            right: self
+                .right
+                .flex_pixels(rem_pixels, remaining_flex, remaining_length),
+        }
+    }
+
+    // pub fn fixed(&self) -> Size<Rems> {
+    //     let mut size = Size::default();
+    //     size.width += self.left.fixed().unwrap_or_default();
+    //     size.width += self.right.fixed().unwrap_or_default();
+    //     size
+    // }
+
+    pub fn flex(&self) -> Vector2F {
+        vec2f(
+            self.left.flex().unwrap_or(0.) + self.right.flex().unwrap_or(0.),
+            self.top.flex().unwrap_or(0.) + self.bottom.flex().unwrap_or(0.),
+        )
+    }
+}
+
+impl Edges<Rems> {
+    pub fn to_pixels(&self, rem_size: f32) -> Edges<f32> {
+        Edges {
+            top: self.top.to_pixels(rem_size),
+            bottom: self.bottom.to_pixels(rem_size),
+            left: self.left.to_pixels(rem_size),
+            right: self.right.to_pixels(rem_size),
+        }
+    }
+}
+
+impl<L> From<L> for Edges<Length>
+where
+    L: Into<Length>,
+{
+    fn from(uniform: L) -> Self {
+        let uniform = uniform.into();
+        Edges {
+            top: uniform,
+            bottom: uniform,
+            left: uniform,
+            right: uniform,
+        }
+    }
+}
+
+impl<Vertical, Horizontal> From<(Vertical, Horizontal)> for Edges<Length>
+where
+    Vertical: Into<Length>,
+    Horizontal: Into<Length>,
+{
+    fn from((vertical, horizontal): (Vertical, Horizontal)) -> Self {
+        let vertical = vertical.into();
+        let horizontal = horizontal.into();
+        Edges {
+            top: vertical,
+            bottom: vertical,
+            left: horizontal,
+            right: horizontal,
+        }
+    }
+}
+
+impl<Top, Bottom, Left, Right> From<(Top, Bottom, Left, Right)> for Edges<Length>
+where
+    Top: Into<Length>,
+    Bottom: Into<Length>,
+    Left: Into<Length>,
+    Right: Into<Length>,
+{
+    fn from((top, bottom, left, right): (Top, Bottom, Left, Right)) -> Self {
+        Edges {
+            top: top.into(),
+            bottom: bottom.into(),
+            left: left.into(),
+            right: right.into(),
+        }
+    }
+}
+
+struct CornerRadii {
+    top_left: f32,
+    top_right: f32,
+    bottom_right: f32,
+    bottom_left: f32,
+}
+
+#[derive(Clone)]
+pub enum Fill {
+    Color(Rgba),
+}
+
+impl<C: Into<Rgba>> From<C> for Fill {
+    fn from(value: C) -> Self {
+        Fill::Color(value.into())
+    }
+}
+
+impl Default for Fill {
+    fn default() -> Self {
+        Fill::Color(Rgba::default())
+    }
+}
+
+#[derive(Clone, Default)]
+struct Borders {
+    color: Color,
+    width: f32,
+    top: bool,
+    bottom: bool,
+    left: bool,
+    right: bool,
+}
+
+impl Borders {
+    fn is_visible(&self) -> bool {
+        self.width > 0.
+            && !self.color.is_fully_transparent()
+            && (self.top || self.bottom || self.left || self.right)
+    }
+
+    fn top_width(&self) -> f32 {
+        if self.top {
+            self.width
+        } else {
+            0.
+        }
+    }
+
+    fn bottom_width(&self) -> f32 {
+        if self.bottom {
+            self.width
+        } else {
+            0.
+        }
+    }
+
+    fn left_width(&self) -> f32 {
+        if self.left {
+            self.width
+        } else {
+            0.
+        }
+    }
+
+    fn right_width(&self) -> f32 {
+        if self.right {
+            self.width
+        } else {
+            0.
+        }
+    }
+
+    fn edges(&self) -> Edges<f32> {
+        let mut edges = Edges::default();
+        if self.width > 0. {
+            if self.top {
+                edges.top = self.width;
+            }
+            if self.bottom {
+                edges.bottom = self.width;
+            }
+            if self.left {
+                edges.left = self.width;
+            }
+            if self.right {
+                edges.right = self.width;
+            }
+        }
+        edges
+    }
+
+    fn size(&self) -> Vector2F {
+        let width =
+            if self.left { self.width } else { 0. } + if self.right { self.width } else { 0. };
+        let height =
+            if self.top { self.width } else { 0. } + if self.bottom { self.width } else { 0. };
+
+        vec2f(width, height)
+    }
+}
+
+pub mod length {
+    use derive_more::{Add, AddAssign, Into};
+
+    #[derive(Add, AddAssign, Into, Clone, Copy, Default, Debug, PartialEq)]
+    pub struct Rems(f32);
+
+    pub fn rems(rems: f32) -> Rems {
+        Rems(rems)
+    }
+
+    impl Rems {
+        pub fn to_pixels(&self, rem_pixels: f32) -> f32 {
+            self.0 * rem_pixels
+        }
+    }
+
+    #[derive(Clone, Copy, Default, Debug)]
+    pub enum Length {
+        #[default]
+        Hug,
+        Fixed(Rems),
+        Auto {
+            flex: f32,
+            min: Rems,
+            max: Rems,
+        },
+    }
+
+    impl From<Rems> for Length {
+        fn from(value: Rems) -> Self {
+            Length::Fixed(value)
+        }
+    }
+
+    pub fn auto() -> Length {
+        flex(1.)
+    }
+
+    pub fn flex(flex: f32) -> Length {
+        Length::Auto {
+            flex,
+            min: Default::default(),
+            max: rems(f32::INFINITY),
+        }
+    }
+
+    pub fn constrained(flex: f32, min: Option<Rems>, max: Option<Rems>) -> Length {
+        Length::Auto {
+            flex,
+            min: min.unwrap_or(Default::default()),
+            max: max.unwrap_or(rems(f32::INFINITY)),
+        }
+    }
+
+    impl Length {
+        pub fn flex_pixels(
+            &self,
+            rem_pixels: f32,
+            remaining_flex: &mut f32,
+            remaining_length: &mut f32,
+        ) -> f32 {
+            match self {
+                Length::Auto { flex, min, max } => {
+                    let flex_length = *remaining_length / *remaining_flex;
+                    let length = (flex * flex_length)
+                        .clamp(min.to_pixels(rem_pixels), max.to_pixels(rem_pixels));
+                    *remaining_flex -= flex;
+                    *remaining_length -= length;
+                    length
+                }
+                _ => 0.,
+            }
+        }
+
+        pub fn fixed_pixels(&self, rem: f32) -> f32 {
+            match self {
+                Length::Fixed(rems) => rems.to_pixels(rem),
+                _ => 0.,
+            }
+        }
+
+        pub fn flex(&self) -> Option<f32> {
+            match self {
+                Length::Auto { flex, .. } => Some(*flex),
+                _ => None,
+            }
+        }
+
+        pub fn fixed(&self) -> Option<Rems> {
+            match self {
+                Length::Fixed(rems) => Some(*rems),
+                _ => None,
+            }
+        }
+    }
+}
+
+#[derive(Clone, Deref, DerefMut)]
+struct Alignment(Vector2F);
+
+impl Default for Alignment {
+    fn default() -> Self {
+        Self(vec2f(-1., -1.))
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+enum Axis3d {
+    X,
+    #[default]
+    Y,
+    Z,
+}
+
+impl Axis3d {
+    fn to_2d(self) -> Option<Axis2d> {
+        match self {
+            Axis3d::X => Some(Axis2d::X),
+            Axis3d::Y => Some(Axis2d::Y),
+            Axis3d::Z => None,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
+pub enum Axis2d {
+    X,
+    #[default]
+    Y,
+}
+
+impl Axis2d {
+    fn rotate(self) -> Self {
+        match self {
+            Axis2d::X => Axis2d::Y,
+            Axis2d::Y => Axis2d::X,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+enum Overflow {
+    #[default]
+    Visible,
+    Hidden,
+    Auto,
+}
+
+#[derive(Clone, Copy)]
+enum Gap {
+    Fixed(f32),
+    Around,
+    Between,
+    Even,
+}
+
+impl Default for Gap {
+    fn default() -> Self {
+        Gap::Fixed(0.)
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+struct Shadow {
+    offset: Vector2F,
+    blur: f32,
+    color: Color,
+}
+
+#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
+enum FontStyle {
+    #[default]
+    Normal,
+    Italic,
+    Oblique,
+}
+
+#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
+enum FontWeight {
+    Thin,
+    ExtraLight,
+    Light,
+    #[default]
+    Normal,
+    Medium,
+    Semibold,
+    Bold,
+    ExtraBold,
+    Black,
+}
+
+#[derive(Default)]
+pub struct Text {
+    text: Cow<'static, str>,
+    highlights: Option<Box<[(Range<usize>, HighlightStyle)]>>,
+    custom_runs: Option<(
+        Box<[Range<usize>]>,
+        Box<dyn FnMut(usize, RectF, &mut SceneBuilder, &mut AppContext)>,
+    )>,
+}
+
+pub fn text<V: 'static>(text: impl Into<Cow<'static, str>>) -> Frame<V> {
+    row().child(Text {
+        text: text.into(),
+        ..Default::default()
+    })
+}
+
+#[derive(Default, Debug)]
+pub struct FrameLayout {
+    size: Vector2F,
+    padding: Edges<f32>,
+    borders: Edges<f32>,
+    margins: Edges<f32>,
+}
+
+impl<V: 'static> Element<V> for Text {
+    type LayoutState = TextLayout;
+    type PaintState = ();
+
+    fn layout(
+        &mut self,
+        constraint: SizeConstraint,
+        _: &mut V,
+        cx: &mut LayoutContext<V>,
+    ) -> (Vector2F, Self::LayoutState) {
+        // Convert the string and highlight ranges into an iterator of highlighted chunks.
+        let mut offset = 0;
+        let mut highlight_ranges = self
+            .highlights
+            .as_ref()
+            .map_or(Default::default(), AsRef::as_ref)
+            .iter()
+            .peekable();
+        let chunks = std::iter::from_fn(|| {
+            let result;
+            if let Some((range, highlight_style)) = highlight_ranges.peek() {
+                if offset < range.start {
+                    result = Some((&self.text[offset..range.start], None));
+                    offset = range.start;
+                } else if range.end <= self.text.len() {
+                    result = Some((&self.text[range.clone()], Some(*highlight_style)));
+                    highlight_ranges.next();
+                    offset = range.end;
+                } else {
+                    warn!(
+                        "Highlight out of text range. Text len: {}, Highlight range: {}..{}",
+                        self.text.len(),
+                        range.start,
+                        range.end
+                    );
+                    result = None;
+                }
+            } else if offset < self.text.len() {
+                result = Some((&self.text[offset..], None));
+                offset = self.text.len();
+            } else {
+                result = None;
+            }
+            result
+        });
+
+        let style = cx.text_style();
+
+        // Perform shaping on these highlighted chunks
+        let shaped_lines = layout_highlighted_chunks(
+            chunks,
+            &style,
+            cx.text_layout_cache(),
+            &cx.font_cache,
+            usize::MAX,
+            self.text.matches('\n').count() + 1,
+        );
+
+        // If line wrapping is enabled, wrap each of the shaped lines.
+        let font_id = style.font_id;
+        let mut line_count = 0;
+        let mut max_line_width = 0_f32;
+        let mut wrap_boundaries = Vec::new();
+        let mut wrapper = cx.font_cache.line_wrapper(font_id, style.font_size);
+        for (line, shaped_line) in self.text.split('\n').zip(&shaped_lines) {
+            if style.soft_wrap {
+                let boundaries = wrapper
+                    .wrap_shaped_line(line, shaped_line, constraint.max.x())
+                    .collect::<Vec<_>>();
+                line_count += boundaries.len() + 1;
+                wrap_boundaries.push(boundaries);
+            } else {
+                line_count += 1;
+            }
+            max_line_width = max_line_width.max(shaped_line.width());
+        }
+
+        let line_height = cx.font_cache.line_height(style.font_size);
+        let size = vec2f(
+            max_line_width
+                .ceil()
+                .max(constraint.min.x())
+                .min(constraint.max.x()),
+            (line_height * line_count as f32).ceil(),
+        );
+        (
+            size,
+            TextLayout {
+                shaped_lines,
+                wrap_boundaries,
+                line_height,
+            },
+        )
+    }
+
+    fn paint(
+        &mut self,
+        scene: &mut SceneBuilder,
+        bounds: RectF,
+        visible_bounds: RectF,
+        layout: &mut Self::LayoutState,
+        _: &mut V,
+        cx: &mut PaintContext<V>,
+    ) -> Self::PaintState {
+        let mut origin = bounds.origin();
+        let empty = Vec::new();
+        let mut callback = |_, _, _: &mut SceneBuilder, _: &mut AppContext| {};
+
+        let mouse_runs;
+        let custom_run_callback;
+        if let Some((runs, build_region)) = &mut self.custom_runs {
+            mouse_runs = runs.iter();
+            custom_run_callback = build_region.as_mut();
+        } else {
+            mouse_runs = [].iter();
+            custom_run_callback = &mut callback;
+        }
+        let mut custom_runs = mouse_runs.enumerate().peekable();
+
+        let mut offset = 0;
+        for (ix, line) in layout.shaped_lines.iter().enumerate() {
+            let wrap_boundaries = layout.wrap_boundaries.get(ix).unwrap_or(&empty);
+            let boundaries = RectF::new(
+                origin,
+                vec2f(
+                    bounds.width(),
+                    (wrap_boundaries.len() + 1) as f32 * layout.line_height,
+                ),
+            );
+
+            let style = cx.text_style();
+            if boundaries.intersects(visible_bounds) {
+                if style.soft_wrap {
+                    line.paint_wrapped(
+                        scene,
+                        origin,
+                        visible_bounds,
+                        layout.line_height,
+                        wrap_boundaries,
+                        cx,
+                    );
+                } else {
+                    line.paint(scene, origin, visible_bounds, layout.line_height, cx);
+                }
+            }
+
+            // Paint any custom runs that intersect this line.
+            let end_offset = offset + line.len();
+            if let Some((custom_run_ix, custom_run_range)) = custom_runs.peek().cloned() {
+                if custom_run_range.start < end_offset {
+                    let mut current_custom_run = None;
+                    if custom_run_range.start <= offset {
+                        current_custom_run = Some((custom_run_ix, custom_run_range.end, origin));
+                    }
+
+                    let mut glyph_origin = origin;
+                    let mut prev_position = 0.;
+                    let mut wrap_boundaries = wrap_boundaries.iter().copied().peekable();
+                    for (run_ix, glyph_ix, glyph) in
+                        line.runs().iter().enumerate().flat_map(|(run_ix, run)| {
+                            run.glyphs()
+                                .iter()
+                                .enumerate()
+                                .map(move |(ix, glyph)| (run_ix, ix, glyph))
+                        })
+                    {
+                        glyph_origin.set_x(glyph_origin.x() + glyph.position.x() - prev_position);
+                        prev_position = glyph.position.x();
+
+                        // If we've reached a soft wrap position, move down one line. If there
+                        // is a custom run in-progress, paint it.
+                        if wrap_boundaries
+                            .peek()
+                            .map_or(false, |b| b.run_ix == run_ix && b.glyph_ix == glyph_ix)
+                        {
+                            if let Some((run_ix, _, run_origin)) = &mut current_custom_run {
+                                let bounds = RectF::from_points(
+                                    *run_origin,
+                                    glyph_origin + vec2f(0., layout.line_height),
+                                );
+                                custom_run_callback(*run_ix, bounds, scene, cx);
+                                *run_origin =
+                                    vec2f(origin.x(), glyph_origin.y() + layout.line_height);
+                            }
+                            wrap_boundaries.next();
+                            glyph_origin = vec2f(origin.x(), glyph_origin.y() + layout.line_height);
+                        }
+
+                        // If we've reached the end of the current custom run, paint it.
+                        if let Some((run_ix, run_end_offset, run_origin)) = current_custom_run {
+                            if offset + glyph.index == run_end_offset {
+                                current_custom_run.take();
+                                let bounds = RectF::from_points(
+                                    run_origin,
+                                    glyph_origin + vec2f(0., layout.line_height),
+                                );
+                                custom_run_callback(run_ix, bounds, scene, cx);
+                                custom_runs.next();
+                            }
+
+                            if let Some((_, run_range)) = custom_runs.peek() {
+                                if run_range.start >= end_offset {
+                                    break;
+                                }
+                                if run_range.start == offset + glyph.index {
+                                    current_custom_run =
+                                        Some((run_ix, run_range.end, glyph_origin));
+                                }
+                            }
+                        }
+
+                        // If we've reached the start of a new custom run, start tracking it.
+                        if let Some((run_ix, run_range)) = custom_runs.peek() {
+                            if offset + glyph.index == run_range.start {
+                                current_custom_run = Some((*run_ix, run_range.end, glyph_origin));
+                            }
+                        }
+                    }
+
+                    // If a custom run extends beyond the end of the line, paint it.
+                    if let Some((run_ix, run_end_offset, run_origin)) = current_custom_run {
+                        let line_end = glyph_origin + vec2f(line.width() - prev_position, 0.);
+                        let bounds = RectF::from_points(
+                            run_origin,
+                            line_end + vec2f(0., layout.line_height),
+                        );
+                        custom_run_callback(run_ix, bounds, scene, cx);
+                        if end_offset == run_end_offset {
+                            custom_runs.next();
+                        }
+                    }
+                }
+            }
+
+            offset = end_offset + 1;
+            origin.set_y(boundaries.max_y());
+        }
+    }
+
+    fn rect_for_text_range(
+        &self,
+        _: Range<usize>,
+        _: RectF,
+        _: RectF,
+        _: &Self::LayoutState,
+        _: &Self::PaintState,
+        _: &V,
+        _: &ViewContext<V>,
+    ) -> Option<RectF> {
+        None
+    }
+
+    fn debug(
+        &self,
+        bounds: RectF,
+        _: &Self::LayoutState,
+        _: &Self::PaintState,
+        _: &V,
+        _: &ViewContext<V>,
+    ) -> Value {
+        json!({
+            "type": "Text",
+            "bounds": bounds.to_json(),
+            "text": &self.text,
+        })
+    }
+}
+
+pub struct TextLayout {
+    shaped_lines: Vec<Line>,
+    wrap_boundaries: Vec<Vec<ShapedBoundary>>,
+    line_height: f32,
+}
+
+trait Vector2FExt {
+    fn infinity() -> Self;
+    fn get(self, axis: Axis2d) -> f32;
+    fn set(&mut self, axis: Axis2d, value: f32);
+    fn increment_x(&mut self, delta: f32) -> f32;
+    fn increment_y(&mut self, delta: f32) -> f32;
+}
+
+impl Vector2FExt for Vector2F {
+    fn infinity() -> Self {
+        vec2f(f32::INFINITY, f32::INFINITY)
+    }
+
+    fn get(self, axis: Axis2d) -> f32 {
+        match axis {
+            Axis2d::X => self.x(),
+            Axis2d::Y => self.y(),
+        }
+    }
+
+    fn set(&mut self, axis: Axis2d, value: f32) {
+        match axis {
+            Axis2d::X => self.set_x(value),
+            Axis2d::Y => self.set_y(value),
+        }
+    }
+
+    fn increment_x(&mut self, delta: f32) -> f32 {
+        self.set_x(self.x() + delta);
+        self.x()
+    }
+
+    fn increment_y(&mut self, delta: f32) -> f32 {
+        self.set_y(self.y() + delta);
+        self.y()
+    }
+}
+
+trait ElementExt<V: 'static> {
+    fn margin_left(self, margin_left: impl Into<Length>) -> Frame<V>
+    where
+        Self: Element<V> + Sized,
+    {
+        column().child(self).margin_left(margin_left)
+    }
+}
+
+impl<V, E> ElementExt<V> for E
+where
+    V: 'static,
+    E: Element<V>,
+{
+    fn margin_left(self, margin_left: impl Into<Length>) -> Frame<V>
+    where
+        Self: Sized,
+    {
+        column().child(self).margin_left(margin_left)
+    }
+}
+
+pub fn view<F, E>(mut render: F) -> ViewFn
+where
+    F: 'static + FnMut(&mut ViewContext<ViewFn>) -> E,
+    E: Element<ViewFn>,
+{
+    ViewFn(Box::new(move |cx| (render)(cx).into_any()))
+}
+
+pub struct ViewFn(Box<dyn FnMut(&mut ViewContext<ViewFn>) -> AnyElement<ViewFn>>);
+
+impl Entity for ViewFn {
+    type Event = ();
+}
+
+impl View for ViewFn {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+        (self.0)(cx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        length::{auto, rems},
+        *,
+    };
+    use crate::themes::rose_pine;
+    use gpui::TestAppContext;
+
+    #[gpui::test]
+    fn test_frame_layout(cx: &mut TestAppContext) {
+        cx.add_window(|_| {
+            view(|_| {
+                let theme = rose_pine::dawn();
+                column()
+                    .width(auto())
+                    .height(auto())
+                    .justify(1.)
+                    .child(
+                        row()
+                            .width(auto())
+                            .height(rems(10.))
+                            .justify(1.)
+                            .child(
+                                row()
+                                    .width(rems(10.))
+                                    .height(auto())
+                                    .fill(theme.surface(1.)),
+                            )
+                            .before_paint(|bounds, layout, cx| {
+                                assert_eq!(bounds.origin(), vec2f(0., 0.));
+                                assert_eq!(layout.size.x(), cx.window_size().x());
+                                assert_eq!(layout.size.y(), rems(10.).to_pixels(cx.rem_pixels()));
+                            }),
+                    )
+                    .child(row())
+                    .before_paint(|bounds, layout, cx| {
+                        assert_eq!(layout.size, cx.window_size());
+                    })
+            })
+        })
+        .remove(cx);
+    }
+}
diff --git a/crates/gpui/playground/ui/src/playground_ui.rs b/crates/gpui/playground/ui/src/playground_ui.rs
new file mode 100644
index 0000000000..3686b00c65
--- /dev/null
+++ b/crates/gpui/playground/ui/src/playground_ui.rs
@@ -0,0 +1,200 @@
+#![allow(dead_code, unused_variables)]
+
+use frame::{length::auto, *};
+use gpui::{AnyElement, Element, LayoutContext, ViewContext};
+use std::{borrow::Cow, cell::RefCell, marker::PhantomData, rc::Rc};
+use themes::{rose_pine, ThemeColors};
+use tokens::{margin::m4, text::lg};
+
+mod color;
+mod frame;
+mod themes;
+mod tokens;
+
+#[derive(Element, Clone, Default)]
+pub struct Playground<V: 'static>(PhantomData<V>);
+
+impl<V> Frame<V> {}
+
+impl<V> Playground<V> {
+    pub fn render(&mut self, _: &mut V, _: &mut gpui::ViewContext<V>) -> impl Element<V> {
+        workspace(&rose_pine::dawn())
+    }
+}
+
+fn workspace<V: 'static>(theme: &ThemeColors) -> impl Element<V> {
+    column()
+        .size(auto())
+        .fill(theme.base(0.1))
+        .child(title_bar(theme))
+        .child(stage(theme))
+        .child(status_bar(theme))
+}
+
+fn title_bar<V: 'static>(theme: &ThemeColors) -> impl Element<V> {
+    row().fill(theme.surface(1.0))
+}
+
+fn stage<V: 'static>(theme: &ThemeColors) -> impl Element<V> {
+    row().fill(theme.surface(0.9))
+}
+
+fn status_bar<V: 'static>(theme: &ThemeColors) -> impl Element<V> {
+    row().fill(theme.surface(0.1))
+}
+
+pub trait DialogDelegate<V>: 'static {}
+
+impl<V> DialogDelegate<V> for () {}
+
+#[derive(Element)]
+pub struct Dialog<V: 'static, D: DialogDelegate<V>> {
+    title: Cow<'static, str>,
+    description: Cow<'static, str>,
+    delegate: Option<Rc<RefCell<D>>>,
+    buttons: Vec<Box<dyn FnOnce() -> AnyElement<V>>>,
+    view_type: PhantomData<V>,
+}
+
+pub fn dialog<V>(
+    title: impl Into<Cow<'static, str>>,
+    description: impl Into<Cow<'static, str>>,
+) -> Dialog<V, ()> {
+    Dialog {
+        title: title.into(),
+        description: description.into(),
+        delegate: None,
+        buttons: Vec::new(),
+        view_type: PhantomData,
+    }
+}
+
+impl<V, D: DialogDelegate<V>> Dialog<V, D> {
+    pub fn delegate(mut self, delegate: D) -> Dialog<V, D> {
+        let old_delegate = self.delegate.replace(Rc::new(RefCell::new(delegate)));
+        debug_assert!(old_delegate.is_none(), "delegate already set");
+        self
+    }
+
+    pub fn button<L, Data, H>(mut self, label: L, data: Data, handler: H) -> Self
+    where
+        L: 'static + Into<Cow<'static, str>>,
+        Data: 'static + Clone,
+        H: ClickHandler<V, Data>,
+    {
+        let label = label.into();
+        self.buttons.push(Box::new(move || {
+            button(label).data(data).click(handler).into_any()
+        }));
+        self
+    }
+}
+
+#[derive(Element)]
+struct Button<V: 'static, D: 'static, H: ClickHandler<V, D>> {
+    label: Cow<'static, str>,
+    click_handler: Option<H>,
+    data: Option<D>,
+    view_type: PhantomData<V>,
+}
+
+pub trait ClickHandler<V, D>: 'static {
+    fn handle(&self, view: &mut V, data: &D, cx: &mut ViewContext<V>);
+}
+
+impl<V, M, F: 'static + Fn(&mut V, &M, &mut ViewContext<V>)> ClickHandler<V, M> for F {
+    fn handle(&self, view: &mut V, data: &M, cx: &mut ViewContext<V>) {
+        self(view, data, cx)
+    }
+}
+
+impl<V, D> ClickHandler<V, D> for () {
+    fn handle(&self, view: &mut V, data: &D, cx: &mut ViewContext<V>) {}
+}
+
+fn button<V>(label: impl Into<Cow<'static, str>>) -> Button<V, (), ()> {
+    Button {
+        label: label.into(),
+        click_handler: None,
+        data: None,
+        view_type: PhantomData,
+    }
+}
+
+impl<V, D, F> Button<V, D, F>
+where
+    F: ClickHandler<V, D>,
+{
+    fn render(&mut self, _: &mut V, _: &mut LayoutContext<V>) -> AnyElement<V> {
+        // TODO! Handle click etc
+        row().child(text(self.label.clone())).into_any()
+    }
+}
+
+// impl<V, D, F> Button<V, D, F>
+// where
+//     V,
+//     F: ClickHandler<V, D>,
+// {
+//     fn render(&mut self, _: &mut V, _: &mut LayoutContext<V>) -> impl Element<V> {
+//         // TODO! Handle click etc
+//         row()
+//             .fill(theme.colors.primary(5))
+//             .child(text(self.label.clone()).text_color(theme.colors.on_primary()))
+//     }
+// }
+
+// struct Tab<V> {
+//     active: bool,
+// }
+
+// impl<V> Tab<V>
+// where
+//     V,
+// {
+//     fn tab(&mut self, _: &mut V, _: &mut LayoutContext<V>) -> impl Element<V> {
+//         let theme = todo!();
+//         // TODO! Handle click etc
+//         row()
+//             .fill(theme.colors.neutral(6))
+//             .child(text(self.label.clone()).text_color(theme.colors.on_neutral()))
+//     }
+// }
+
+impl<V> Button<V, (), ()> {
+    fn data<D>(self, data: D) -> Button<V, D, ()>
+    where
+        D: 'static,
+    {
+        Button {
+            label: self.label,
+            click_handler: self.click_handler,
+            data: Some(data),
+            view_type: self.view_type,
+        }
+    }
+}
+
+impl<V, D> Button<V, D, ()> {
+    fn click<H>(self, handler: H) -> Button<V, D, H>
+    where
+        H: 'static + ClickHandler<V, D>,
+    {
+        Button {
+            label: self.label,
+            click_handler: Some(handler),
+            data: self.data,
+            view_type: self.view_type,
+        }
+    }
+}
+
+impl<V, D: DialogDelegate<V>> Dialog<V, D> {
+    pub fn render(&mut self, _: &mut V, _: &mut gpui::ViewContext<V>) -> AnyElement<V> {
+        column()
+            .child(text(self.title.clone()).text_size(lg()))
+            .child(text(self.description.clone()).margins((m4(), auto())))
+            .child(row().children(self.buttons.drain(..).map(|button| (button)())))
+            .into_any()
+    }
+}
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 2a9d9f4768..2fd399b137 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -7,42 +7,6 @@ pub mod test_app_context;
 pub(crate) mod window;
 mod window_input_handler;
 
-use std::{
-    any::{type_name, Any, TypeId},
-    cell::RefCell,
-    fmt::{self, Debug},
-    hash::{Hash, Hasher},
-    marker::PhantomData,
-    mem,
-    ops::{Deref, DerefMut, Range},
-    path::{Path, PathBuf},
-    pin::Pin,
-    rc::{self, Rc},
-    sync::{Arc, Weak},
-    time::Duration,
-};
-
-use anyhow::{anyhow, Context, Result};
-
-use derive_more::Deref;
-use parking_lot::Mutex;
-use postage::oneshot;
-use smallvec::SmallVec;
-use smol::prelude::*;
-use util::ResultExt;
-use uuid::Uuid;
-
-pub use action::*;
-use callback_collection::CallbackCollection;
-use collections::{hash_map::Entry, BTreeMap, HashMap, HashSet, VecDeque};
-pub use menu::*;
-use platform::Event;
-#[cfg(any(test, feature = "test-support"))]
-use ref_counts::LeakDetector;
-#[cfg(any(test, feature = "test-support"))]
-pub use test_app_context::{ContextHandle, TestAppContext};
-use window_input_handler::WindowInputHandler;
-
 use crate::{
     elements::{AnyElement, AnyRootElement, RootElement},
     executor::{self, Task},
@@ -57,8 +21,39 @@ use crate::{
     window::{Window, WindowContext},
     AssetCache, AssetSource, ClipboardItem, FontCache, MouseRegionId,
 };
-
-use self::ref_counts::RefCounts;
+pub use action::*;
+use anyhow::{anyhow, Context, Result};
+use callback_collection::CallbackCollection;
+use collections::{hash_map::Entry, BTreeMap, HashMap, HashSet, VecDeque};
+use derive_more::Deref;
+pub use menu::*;
+use parking_lot::Mutex;
+use platform::Event;
+use postage::oneshot;
+#[cfg(any(test, feature = "test-support"))]
+use ref_counts::LeakDetector;
+use ref_counts::RefCounts;
+use smallvec::SmallVec;
+use smol::prelude::*;
+use std::{
+    any::{type_name, Any, TypeId},
+    cell::RefCell,
+    fmt::{self, Debug},
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+    mem,
+    ops::{Deref, DerefMut, Range},
+    path::{Path, PathBuf},
+    pin::Pin,
+    rc::{self, Rc},
+    sync::{Arc, Weak},
+    time::Duration,
+};
+#[cfg(any(test, feature = "test-support"))]
+pub use test_app_context::{ContextHandle, TestAppContext};
+use util::ResultExt;
+use uuid::Uuid;
+use window_input_handler::WindowInputHandler;
 
 pub trait Entity: 'static {
     type Event;
@@ -632,7 +627,7 @@ impl AppContext {
     pub fn add_action<A, V, F, R>(&mut self, handler: F)
     where
         A: Action,
-        V: View,
+        V: 'static,
         F: 'static + FnMut(&mut V, &A, &mut ViewContext<V>) -> R,
     {
         self.add_action_internal(handler, false)
@@ -641,7 +636,7 @@ impl AppContext {
     pub fn capture_action<A, V, F>(&mut self, handler: F)
     where
         A: Action,
-        V: View,
+        V: 'static,
         F: 'static + FnMut(&mut V, &A, &mut ViewContext<V>),
     {
         self.add_action_internal(handler, true)
@@ -650,7 +645,7 @@ impl AppContext {
     fn add_action_internal<A, V, F, R>(&mut self, mut handler: F, capture: bool)
     where
         A: Action,
-        V: View,
+        V: 'static,
         F: 'static + FnMut(&mut V, &A, &mut ViewContext<V>) -> R,
     {
         let handler = Box::new(
@@ -691,7 +686,7 @@ impl AppContext {
     pub fn add_async_action<A, V, F>(&mut self, mut handler: F)
     where
         A: Action,
-        V: View,
+        V: 'static,
         F: 'static + FnMut(&mut V, &A, &mut ViewContext<V>) -> Option<Task<Result<()>>>,
     {
         self.add_action(move |view, action, cx| {
@@ -890,8 +885,8 @@ impl AppContext {
 
     fn observe_focus<F, V>(&mut self, handle: &ViewHandle<V>, mut callback: F) -> Subscription
     where
+        V: 'static,
         F: 'static + FnMut(ViewHandle<V>, bool, &mut WindowContext) -> bool,
-        V: View,
     {
         let subscription_id = post_inc(&mut self.next_subscription_id);
         let observed = handle.downgrade();
@@ -1374,15 +1369,15 @@ impl AppContext {
         self.windows.keys().copied()
     }
 
-    pub fn read_view<T: View>(&self, handle: &ViewHandle<T>) -> &T {
+    pub fn read_view<V: 'static>(&self, handle: &ViewHandle<V>) -> &V {
         if let Some(view) = self.views.get(&(handle.window, handle.view_id)) {
             view.as_any().downcast_ref().expect("downcast is type safe")
         } else {
-            panic!("circular view reference for type {}", type_name::<T>());
+            panic!("circular view reference for type {}", type_name::<V>());
         }
     }
 
-    fn upgrade_view_handle<T: View>(&self, handle: &WeakViewHandle<T>) -> Option<ViewHandle<T>> {
+    fn upgrade_view_handle<V: 'static>(&self, handle: &WeakViewHandle<V>) -> Option<ViewHandle<V>> {
         if self.ref_counts.lock().is_entity_alive(handle.view_id) {
             Some(ViewHandle::new(
                 handle.window,
@@ -2535,10 +2530,7 @@ pub trait AnyView {
     }
 }
 
-impl<V> AnyView for V
-where
-    V: View,
-{
+impl<V: View> AnyView for V {
     fn as_any(&self) -> &dyn Any {
         self
     }
@@ -2870,7 +2862,7 @@ pub struct ViewContext<'a, 'b, T: ?Sized> {
     view_type: PhantomData<T>,
 }
 
-impl<'a, 'b, T: View> Deref for ViewContext<'a, 'b, T> {
+impl<'a, 'b, V> Deref for ViewContext<'a, 'b, V> {
     type Target = WindowContext<'a>;
 
     fn deref(&self) -> &Self::Target {
@@ -2878,13 +2870,13 @@ impl<'a, 'b, T: View> Deref for ViewContext<'a, 'b, T> {
     }
 }
 
-impl<T: View> DerefMut for ViewContext<'_, '_, T> {
+impl<'a, 'b, V> DerefMut for ViewContext<'a, 'b, V> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.window_context
     }
 }
 
-impl<'a, 'b, V: View> ViewContext<'a, 'b, V> {
+impl<'a, 'b, V: 'static> ViewContext<'a, 'b, V> {
     pub(crate) fn mutable(window_context: &'b mut WindowContext<'a>, view_id: usize) -> Self {
         Self {
             window_context: Reference::Mutable(window_context),
@@ -2905,6 +2897,12 @@ impl<'a, 'b, V: View> ViewContext<'a, 'b, V> {
         &mut self.window_context
     }
 
+    pub fn notify(&mut self) {
+        let window = self.window_handle;
+        let view_id = self.view_id;
+        self.window_context.notify_view(window, view_id);
+    }
+
     pub fn handle(&self) -> ViewHandle<V> {
         ViewHandle::new(
             self.window_handle,
@@ -3218,21 +3216,6 @@ impl<'a, 'b, V: View> ViewContext<'a, 'b, V> {
         })
     }
 
-    pub fn emit(&mut self, payload: V::Event) {
-        self.window_context
-            .pending_effects
-            .push_back(Effect::Event {
-                entity_id: self.view_id,
-                payload: Box::new(payload),
-            });
-    }
-
-    pub fn notify(&mut self) {
-        let window = self.window_handle;
-        let view_id = self.view_id;
-        self.window_context.notify_view(window, view_id);
-    }
-
     pub fn defer(&mut self, callback: impl 'static + FnOnce(&mut V, &mut ViewContext<V>)) {
         let handle = self.handle();
         self.window_context
@@ -3321,6 +3304,17 @@ impl<'a, 'b, V: View> ViewContext<'a, 'b, V> {
     }
 }
 
+impl<V: View> ViewContext<'_, '_, V> {
+    pub fn emit(&mut self, payload: V::Event) {
+        self.window_context
+            .pending_effects
+            .push_back(Effect::Event {
+                entity_id: self.view_id,
+                payload: Box::new(payload),
+            });
+    }
+}
+
 impl<V> BorrowAppContext for ViewContext<'_, '_, V> {
     fn read_with<T, F: FnOnce(&AppContext) -> T>(&self, f: F) -> T {
         BorrowAppContext::read_with(&*self.window_context, f)
@@ -3361,7 +3355,7 @@ impl<V> BorrowWindowContext for ViewContext<'_, '_, V> {
     }
 }
 
-pub struct LayoutContext<'a, 'b, 'c, V: View> {
+pub struct LayoutContext<'a, 'b, 'c, V> {
     view_context: &'c mut ViewContext<'a, 'b, V>,
     new_parents: &'c mut HashMap<usize, usize>,
     views_to_notify_if_ancestors_change: &'c mut HashMap<usize, SmallVec<[usize; 2]>>,
@@ -3369,7 +3363,7 @@ pub struct LayoutContext<'a, 'b, 'c, V: View> {
     pub refreshing: bool,
 }
 
-impl<'a, 'b, 'c, V: View> LayoutContext<'a, 'b, 'c, V> {
+impl<'a, 'b, 'c, V> LayoutContext<'a, 'b, 'c, V> {
     pub fn new(
         view_context: &'c mut ViewContext<'a, 'b, V>,
         new_parents: &'c mut HashMap<usize, usize>,
@@ -3452,7 +3446,7 @@ impl<'a, 'b, 'c, V: View> LayoutContext<'a, 'b, 'c, V> {
     }
 }
 
-impl<'a, 'b, 'c, V: View> Deref for LayoutContext<'a, 'b, 'c, V> {
+impl<'a, 'b, 'c, V> Deref for LayoutContext<'a, 'b, 'c, V> {
     type Target = ViewContext<'a, 'b, V>;
 
     fn deref(&self) -> &Self::Target {
@@ -3460,13 +3454,13 @@ impl<'a, 'b, 'c, V: View> Deref for LayoutContext<'a, 'b, 'c, V> {
     }
 }
 
-impl<V: View> DerefMut for LayoutContext<'_, '_, '_, V> {
+impl<V> DerefMut for LayoutContext<'_, '_, '_, V> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.view_context
     }
 }
 
-impl<V: View> BorrowAppContext for LayoutContext<'_, '_, '_, V> {
+impl<V> BorrowAppContext for LayoutContext<'_, '_, '_, V> {
     fn read_with<T, F: FnOnce(&AppContext) -> T>(&self, f: F) -> T {
         BorrowAppContext::read_with(&*self.view_context, f)
     }
@@ -3476,7 +3470,7 @@ impl<V: View> BorrowAppContext for LayoutContext<'_, '_, '_, V> {
     }
 }
 
-impl<V: View> BorrowWindowContext for LayoutContext<'_, '_, '_, V> {
+impl<V> BorrowWindowContext for LayoutContext<'_, '_, '_, V> {
     type Result<T> = T;
 
     fn read_window<T, F: FnOnce(&WindowContext) -> T>(&self, window: AnyWindowHandle, f: F) -> T {
@@ -3506,12 +3500,12 @@ impl<V: View> BorrowWindowContext for LayoutContext<'_, '_, '_, V> {
     }
 }
 
-pub struct PaintContext<'a, 'b, 'c, V: View> {
+pub struct PaintContext<'a, 'b, 'c, V> {
     view_context: &'c mut ViewContext<'a, 'b, V>,
     text_style_stack: Vec<Arc<TextStyle>>,
 }
 
-impl<'a, 'b, 'c, V: View> PaintContext<'a, 'b, 'c, V> {
+impl<'a, 'b, 'c, V> PaintContext<'a, 'b, 'c, V> {
     pub fn new(view_context: &'c mut ViewContext<'a, 'b, V>) -> Self {
         Self {
             view_context,
@@ -3538,7 +3532,7 @@ impl<'a, 'b, 'c, V: View> PaintContext<'a, 'b, 'c, V> {
     }
 }
 
-impl<'a, 'b, 'c, V: View> Deref for PaintContext<'a, 'b, 'c, V> {
+impl<'a, 'b, 'c, V> Deref for PaintContext<'a, 'b, 'c, V> {
     type Target = ViewContext<'a, 'b, V>;
 
     fn deref(&self) -> &Self::Target {
@@ -3546,13 +3540,13 @@ impl<'a, 'b, 'c, V: View> Deref for PaintContext<'a, 'b, 'c, V> {
     }
 }
 
-impl<V: View> DerefMut for PaintContext<'_, '_, '_, V> {
+impl<V> DerefMut for PaintContext<'_, '_, '_, V> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.view_context
     }
 }
 
-impl<V: View> BorrowAppContext for PaintContext<'_, '_, '_, V> {
+impl<V> BorrowAppContext for PaintContext<'_, '_, '_, V> {
     fn read_with<T, F: FnOnce(&AppContext) -> T>(&self, f: F) -> T {
         BorrowAppContext::read_with(&*self.view_context, f)
     }
@@ -3562,7 +3556,7 @@ impl<V: View> BorrowAppContext for PaintContext<'_, '_, '_, V> {
     }
 }
 
-impl<V: View> BorrowWindowContext for PaintContext<'_, '_, '_, V> {
+impl<V> BorrowWindowContext for PaintContext<'_, '_, '_, V> {
     type Result<T> = T;
 
     fn read_window<T, F>(&self, window: AnyWindowHandle, f: F) -> Self::Result<T>
@@ -3594,12 +3588,12 @@ impl<V: View> BorrowWindowContext for PaintContext<'_, '_, '_, V> {
     }
 }
 
-pub struct EventContext<'a, 'b, 'c, V: View> {
+pub struct EventContext<'a, 'b, 'c, V> {
     view_context: &'c mut ViewContext<'a, 'b, V>,
     pub(crate) handled: bool,
 }
 
-impl<'a, 'b, 'c, V: View> EventContext<'a, 'b, 'c, V> {
+impl<'a, 'b, 'c, V> EventContext<'a, 'b, 'c, V> {
     pub(crate) fn new(view_context: &'c mut ViewContext<'a, 'b, V>) -> Self {
         EventContext {
             view_context,
@@ -3612,7 +3606,7 @@ impl<'a, 'b, 'c, V: View> EventContext<'a, 'b, 'c, V> {
     }
 }
 
-impl<'a, 'b, 'c, V: View> Deref for EventContext<'a, 'b, 'c, V> {
+impl<'a, 'b, 'c, V> Deref for EventContext<'a, 'b, 'c, V> {
     type Target = ViewContext<'a, 'b, V>;
 
     fn deref(&self) -> &Self::Target {
@@ -3620,13 +3614,13 @@ impl<'a, 'b, 'c, V: View> Deref for EventContext<'a, 'b, 'c, V> {
     }
 }
 
-impl<V: View> DerefMut for EventContext<'_, '_, '_, V> {
+impl<V> DerefMut for EventContext<'_, '_, '_, V> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.view_context
     }
 }
 
-impl<V: View> BorrowAppContext for EventContext<'_, '_, '_, V> {
+impl<V> BorrowAppContext for EventContext<'_, '_, '_, V> {
     fn read_with<T, F: FnOnce(&AppContext) -> T>(&self, f: F) -> T {
         BorrowAppContext::read_with(&*self.view_context, f)
     }
@@ -3636,7 +3630,7 @@ impl<V: View> BorrowAppContext for EventContext<'_, '_, '_, V> {
     }
 }
 
-impl<V: View> BorrowWindowContext for EventContext<'_, '_, '_, V> {
+impl<V> BorrowWindowContext for EventContext<'_, '_, '_, V> {
     type Result<T> = T;
 
     fn read_window<T, F: FnOnce(&WindowContext) -> T>(&self, window: AnyWindowHandle, f: F) -> T {
@@ -3964,7 +3958,7 @@ impl<V> Clone for WindowHandle<V> {
 
 impl<V> Copy for WindowHandle<V> {}
 
-impl<V: View> WindowHandle<V> {
+impl<V: 'static> WindowHandle<V> {
     fn new(window_id: usize) -> Self {
         WindowHandle {
             any_handle: AnyWindowHandle::new(window_id, TypeId::of::<V>()),
@@ -4002,7 +3996,9 @@ impl<V: View> WindowHandle<V> {
                 .update(cx, update)
         })
     }
+}
 
+impl<V: View> WindowHandle<V> {
     pub fn replace_root<C, F>(&self, cx: &mut C, build_root: F) -> C::Result<ViewHandle<V>>
     where
         C: BorrowWindowContext,
@@ -4082,7 +4078,7 @@ impl AnyWindowHandle {
         self.update(cx, |cx| cx.add_view(build_view))
     }
 
-    pub fn downcast<V: View>(self) -> Option<WindowHandle<V>> {
+    pub fn downcast<V: 'static>(self) -> Option<WindowHandle<V>> {
         if self.root_view_type == TypeId::of::<V>() {
             Some(WindowHandle {
                 any_handle: self,
@@ -4093,7 +4089,7 @@ impl AnyWindowHandle {
         }
     }
 
-    pub fn root_is<V: View>(&self) -> bool {
+    pub fn root_is<V: 'static>(&self) -> bool {
         self.root_view_type == TypeId::of::<V>()
     }
 
@@ -4171,9 +4167,9 @@ impl AnyWindowHandle {
 }
 
 #[repr(transparent)]
-pub struct ViewHandle<T> {
+pub struct ViewHandle<V> {
     any_handle: AnyViewHandle,
-    view_type: PhantomData<T>,
+    view_type: PhantomData<V>,
 }
 
 impl<T> Deref for ViewHandle<T> {
@@ -4184,15 +4180,15 @@ impl<T> Deref for ViewHandle<T> {
     }
 }
 
-impl<T: View> ViewHandle<T> {
+impl<V: 'static> ViewHandle<V> {
     fn new(window: AnyWindowHandle, view_id: usize, ref_counts: &Arc<Mutex<RefCounts>>) -> Self {
         Self {
-            any_handle: AnyViewHandle::new(window, view_id, TypeId::of::<T>(), ref_counts.clone()),
+            any_handle: AnyViewHandle::new(window, view_id, TypeId::of::<V>(), ref_counts.clone()),
             view_type: PhantomData,
         }
     }
 
-    pub fn downgrade(&self) -> WeakViewHandle<T> {
+    pub fn downgrade(&self) -> WeakViewHandle<V> {
         WeakViewHandle::new(self.window, self.view_id)
     }
 
@@ -4208,14 +4204,14 @@ impl<T: View> ViewHandle<T> {
         self.view_id
     }
 
-    pub fn read<'a>(&self, cx: &'a AppContext) -> &'a T {
+    pub fn read<'a>(&self, cx: &'a AppContext) -> &'a V {
         cx.read_view(self)
     }
 
     pub fn read_with<C, F, S>(&self, cx: &C, read: F) -> C::Result<S>
     where
         C: BorrowWindowContext,
-        F: FnOnce(&T, &ViewContext<T>) -> S,
+        F: FnOnce(&V, &ViewContext<V>) -> S,
     {
         cx.read_window(self.window, |cx| {
             let cx = ViewContext::immutable(cx, self.view_id);
@@ -4226,7 +4222,7 @@ impl<T: View> ViewHandle<T> {
     pub fn update<C, F, S>(&self, cx: &mut C, update: F) -> C::Result<S>
     where
         C: BorrowWindowContext,
-        F: FnOnce(&mut T, &mut ViewContext<T>) -> S,
+        F: FnOnce(&mut V, &mut ViewContext<V>) -> S,
     {
         let mut update = Some(update);
 
@@ -4362,8 +4358,8 @@ impl AnyViewHandle {
         TypeId::of::<T>() == self.view_type
     }
 
-    pub fn downcast<T: View>(self) -> Option<ViewHandle<T>> {
-        if self.is::<T>() {
+    pub fn downcast<V: 'static>(self) -> Option<ViewHandle<V>> {
+        if self.is::<V>() {
             Some(ViewHandle {
                 any_handle: self,
                 view_type: PhantomData,
@@ -4373,8 +4369,8 @@ impl AnyViewHandle {
         }
     }
 
-    pub fn downcast_ref<T: View>(&self) -> Option<&ViewHandle<T>> {
-        if self.is::<T>() {
+    pub fn downcast_ref<V: 'static>(&self) -> Option<&ViewHandle<V>> {
+        if self.is::<V>() {
             Some(unsafe { mem::transmute(self) })
         } else {
             None
@@ -4573,7 +4569,7 @@ impl<T> WeakHandle for WeakViewHandle<T> {
     }
 }
 
-impl<V: View> WeakViewHandle<V> {
+impl<V: 'static> WeakViewHandle<V> {
     fn new(window: AnyWindowHandle, view_id: usize) -> Self {
         Self {
             any_handle: AnyWeakViewHandle {
@@ -4613,7 +4609,7 @@ impl<V: View> WeakViewHandle<V> {
         cx.read(|cx| {
             let handle = cx
                 .upgrade_view_handle(self)
-                .ok_or_else(|| anyhow!("view {} was dropped", V::ui_name()))?;
+                .ok_or_else(|| anyhow!("view was dropped"))?;
             cx.read_window(self.window, |cx| handle.read_with(cx, read))
                 .ok_or_else(|| anyhow!("window was removed"))
         })
@@ -4627,14 +4623,14 @@ impl<V: View> WeakViewHandle<V> {
         cx.update(|cx| {
             let handle = cx
                 .upgrade_view_handle(self)
-                .ok_or_else(|| anyhow!("view {} was dropped", V::ui_name()))?;
+                .ok_or_else(|| anyhow!("view was dropped"))?;
             cx.update_window(self.window, |cx| handle.update(cx, update))
                 .ok_or_else(|| anyhow!("window was removed"))
         })
     }
 }
 
-impl<T> Deref for WeakViewHandle<T> {
+impl<V> Deref for WeakViewHandle<V> {
     type Target = AnyWeakViewHandle;
 
     fn deref(&self) -> &Self::Target {
@@ -4642,7 +4638,7 @@ impl<T> Deref for WeakViewHandle<T> {
     }
 }
 
-impl<T> Clone for WeakViewHandle<T> {
+impl<V> Clone for WeakViewHandle<V> {
     fn clone(&self) -> Self {
         Self {
             any_handle: self.any_handle.clone(),
diff --git a/crates/gpui/src/app/window.rs b/crates/gpui/src/app/window.rs
index 12a9adafcb..b7ad17c54e 100644
--- a/crates/gpui/src/app/window.rs
+++ b/crates/gpui/src/app/window.rs
@@ -67,8 +67,8 @@ impl Window {
         build_view: F,
     ) -> Self
     where
-        F: FnOnce(&mut ViewContext<V>) -> V,
         V: View,
+        F: FnOnce(&mut ViewContext<V>) -> V,
     {
         let titlebar_height = platform_window.titlebar_height();
         let appearance = platform_window.appearance();
@@ -242,14 +242,11 @@ impl<'a> WindowContext<'a> {
         Some(result)
     }
 
-    pub(crate) fn update_view<T, S>(
+    pub(crate) fn update_view<V: 'static, S>(
         &mut self,
-        handle: &ViewHandle<T>,
-        update: &mut dyn FnMut(&mut T, &mut ViewContext<T>) -> S,
-    ) -> S
-    where
-        T: View,
-    {
+        handle: &ViewHandle<V>,
+        update: &mut dyn FnMut(&mut V, &mut ViewContext<V>) -> S,
+    ) -> S {
         self.update_any_view(handle.view_id, |view, cx| {
             let mut cx = ViewContext::mutable(cx, handle.view_id);
             update(
@@ -1393,7 +1390,7 @@ impl ChildView {
     }
 }
 
-impl<V: View> Element<V> for ChildView {
+impl<V: 'static> Element<V> for ChildView {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements.rs b/crates/gpui/src/elements.rs
index 5bed935319..e603b6a1e2 100644
--- a/crates/gpui/src/elements.rs
+++ b/crates/gpui/src/elements.rs
@@ -43,7 +43,7 @@ use json::ToJson;
 use smallvec::SmallVec;
 use std::{any::Any, borrow::Cow, mem, ops::Range};
 
-pub trait Element<V: View>: 'static {
+pub trait Element<V: 'static>: 'static {
     type LayoutState;
     type PaintState;
 
@@ -201,7 +201,7 @@ pub trait Element<V: View>: 'static {
     }
 }
 
-trait AnyElementState<V: View> {
+trait AnyElementState<V> {
     fn layout(
         &mut self,
         constraint: SizeConstraint,
@@ -232,7 +232,7 @@ trait AnyElementState<V: View> {
     fn metadata(&self) -> Option<&dyn Any>;
 }
 
-enum ElementState<V: View, E: Element<V>> {
+enum ElementState<V: 'static, E: Element<V>> {
     Empty,
     Init {
         element: E,
@@ -253,7 +253,7 @@ enum ElementState<V: View, E: Element<V>> {
     },
 }
 
-impl<V: View, E: Element<V>> AnyElementState<V> for ElementState<V, E> {
+impl<V, E: Element<V>> AnyElementState<V> for ElementState<V, E> {
     fn layout(
         &mut self,
         constraint: SizeConstraint,
@@ -427,18 +427,18 @@ impl<V: View, E: Element<V>> AnyElementState<V> for ElementState<V, E> {
     }
 }
 
-impl<V: View, E: Element<V>> Default for ElementState<V, E> {
+impl<V, E: Element<V>> Default for ElementState<V, E> {
     fn default() -> Self {
         Self::Empty
     }
 }
 
-pub struct AnyElement<V: View> {
+pub struct AnyElement<V> {
     state: Box<dyn AnyElementState<V>>,
     name: Option<Cow<'static, str>>,
 }
 
-impl<V: View> AnyElement<V> {
+impl<V> AnyElement<V> {
     pub fn name(&self) -> Option<&str> {
         self.name.as_deref()
     }
@@ -506,7 +506,7 @@ impl<V: View> AnyElement<V> {
     }
 }
 
-impl<V: View> Element<V> for AnyElement<V> {
+impl<V: 'static> Element<V> for AnyElement<V> {
     type LayoutState = ();
     type PaintState = ();
 
@@ -564,12 +564,12 @@ impl<V: View> Element<V> for AnyElement<V> {
     }
 }
 
-pub struct RootElement<V: View> {
+pub struct RootElement<V> {
     element: AnyElement<V>,
     view: WeakViewHandle<V>,
 }
 
-impl<V: View> RootElement<V> {
+impl<V> RootElement<V> {
     pub fn new(element: AnyElement<V>, view: WeakViewHandle<V>) -> Self {
         Self { element, view }
     }
@@ -677,7 +677,7 @@ impl<V: View> AnyRootElement for RootElement<V> {
     }
 }
 
-pub trait ParentElement<'a, V: View>: Extend<AnyElement<V>> + Sized {
+pub trait ParentElement<'a, V: 'static>: Extend<AnyElement<V>> + Sized {
     fn add_children<E: Element<V>>(&mut self, children: impl IntoIterator<Item = E>) {
         self.extend(children.into_iter().map(|child| child.into_any()));
     }
@@ -697,7 +697,12 @@ pub trait ParentElement<'a, V: View>: Extend<AnyElement<V>> + Sized {
     }
 }
 
-impl<'a, V: View, T> ParentElement<'a, V> for T where T: Extend<AnyElement<V>> {}
+impl<'a, V, T> ParentElement<'a, V> for T
+where
+    V: 'static,
+    T: Extend<AnyElement<V>>,
+{
+}
 
 pub fn constrain_size_preserving_aspect_ratio(max_size: Vector2F, size: Vector2F) -> Vector2F {
     if max_size.x().is_infinite() && max_size.y().is_infinite() {
diff --git a/crates/gpui/src/elements/align.rs b/crates/gpui/src/elements/align.rs
index e60c1ff907..1312c336fb 100644
--- a/crates/gpui/src/elements/align.rs
+++ b/crates/gpui/src/elements/align.rs
@@ -1,18 +1,18 @@
 use crate::{
     geometry::{rect::RectF, vector::Vector2F},
-    json, AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, View,
+    json, AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint,
     ViewContext,
 };
 use json::ToJson;
 
 use serde_json::json;
 
-pub struct Align<V: View> {
+pub struct Align<V> {
     child: AnyElement<V>,
     alignment: Vector2F,
 }
 
-impl<V: View> Align<V> {
+impl<V> Align<V> {
     pub fn new(child: AnyElement<V>) -> Self {
         Self {
             child,
@@ -41,7 +41,7 @@ impl<V: View> Align<V> {
     }
 }
 
-impl<V: View> Element<V> for Align<V> {
+impl<V: 'static> Element<V> for Align<V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/canvas.rs b/crates/gpui/src/elements/canvas.rs
index 2d33ba45e5..d169efb3d9 100644
--- a/crates/gpui/src/elements/canvas.rs
+++ b/crates/gpui/src/elements/canvas.rs
@@ -3,7 +3,7 @@ use std::marker::PhantomData;
 use super::Element;
 use crate::{
     json::{self, json},
-    PaintContext, SceneBuilder, View, ViewContext,
+    PaintContext, SceneBuilder, ViewContext,
 };
 use json::ToJson;
 use pathfinder_geometry::{
@@ -15,7 +15,6 @@ pub struct Canvas<V, F>(F, PhantomData<V>);
 
 impl<V, F> Canvas<V, F>
 where
-    V: View,
     F: FnMut(&mut SceneBuilder, RectF, RectF, &mut V, &mut ViewContext<V>),
 {
     pub fn new(f: F) -> Self {
@@ -23,7 +22,7 @@ where
     }
 }
 
-impl<V: View, F> Element<V> for Canvas<V, F>
+impl<V: 'static, F> Element<V> for Canvas<V, F>
 where
     F: 'static + FnMut(&mut SceneBuilder, RectF, RectF, &mut V, &mut ViewContext<V>),
 {
diff --git a/crates/gpui/src/elements/clipped.rs b/crates/gpui/src/elements/clipped.rs
index 4e8cd4bc15..64f22515b3 100644
--- a/crates/gpui/src/elements/clipped.rs
+++ b/crates/gpui/src/elements/clipped.rs
@@ -4,21 +4,21 @@ use pathfinder_geometry::{rect::RectF, vector::Vector2F};
 use serde_json::json;
 
 use crate::{
-    json, AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, View,
+    json, AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint,
     ViewContext,
 };
 
-pub struct Clipped<V: View> {
+pub struct Clipped<V> {
     child: AnyElement<V>,
 }
 
-impl<V: View> Clipped<V> {
+impl<V> Clipped<V> {
     pub fn new(child: AnyElement<V>) -> Self {
         Self { child }
     }
 }
 
-impl<V: View> Element<V> for Clipped<V> {
+impl<V: 'static> Element<V> for Clipped<V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/constrained_box.rs b/crates/gpui/src/elements/constrained_box.rs
index 0d540a47b4..495b6c69dc 100644
--- a/crates/gpui/src/elements/constrained_box.rs
+++ b/crates/gpui/src/elements/constrained_box.rs
@@ -5,21 +5,21 @@ use serde_json::json;
 
 use crate::{
     geometry::{rect::RectF, vector::Vector2F},
-    json, AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, View,
+    json, AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint,
     ViewContext,
 };
 
-pub struct ConstrainedBox<V: View> {
+pub struct ConstrainedBox<V> {
     child: AnyElement<V>,
     constraint: Constraint<V>,
 }
 
-pub enum Constraint<V: View> {
+pub enum Constraint<V> {
     Static(SizeConstraint),
     Dynamic(Box<dyn FnMut(SizeConstraint, &mut V, &mut LayoutContext<V>) -> SizeConstraint>),
 }
 
-impl<V: View> ToJson for Constraint<V> {
+impl<V> ToJson for Constraint<V> {
     fn to_json(&self) -> serde_json::Value {
         match self {
             Constraint::Static(constraint) => constraint.to_json(),
@@ -28,7 +28,7 @@ impl<V: View> ToJson for Constraint<V> {
     }
 }
 
-impl<V: View> ConstrainedBox<V> {
+impl<V: 'static> ConstrainedBox<V> {
     pub fn new(child: impl Element<V>) -> Self {
         Self {
             child: child.into_any(),
@@ -132,7 +132,7 @@ impl<V: View> ConstrainedBox<V> {
     }
 }
 
-impl<V: View> Element<V> for ConstrainedBox<V> {
+impl<V: 'static> Element<V> for ConstrainedBox<V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/container.rs b/crates/gpui/src/elements/container.rs
index 656847980c..699a9bdeb0 100644
--- a/crates/gpui/src/elements/container.rs
+++ b/crates/gpui/src/elements/container.rs
@@ -10,8 +10,7 @@ use crate::{
     json::ToJson,
     platform::CursorStyle,
     scene::{self, Border, CursorRegion, Quad},
-    AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, View,
-    ViewContext,
+    AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, ViewContext,
 };
 use schemars::JsonSchema;
 use serde::Deserialize;
@@ -37,12 +36,12 @@ pub struct ContainerStyle {
     pub cursor: Option<CursorStyle>,
 }
 
-pub struct Container<V: View> {
+pub struct Container<V> {
     child: AnyElement<V>,
     style: ContainerStyle,
 }
 
-impl<V: View> Container<V> {
+impl<V> Container<V> {
     pub fn new(child: AnyElement<V>) -> Self {
         Self {
             child,
@@ -186,7 +185,7 @@ impl<V: View> Container<V> {
     }
 }
 
-impl<V: View> Element<V> for Container<V> {
+impl<V: 'static> Element<V> for Container<V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/empty.rs b/crates/gpui/src/elements/empty.rs
index 7058068453..04b1c70213 100644
--- a/crates/gpui/src/elements/empty.rs
+++ b/crates/gpui/src/elements/empty.rs
@@ -6,7 +6,7 @@ use crate::{
         vector::{vec2f, Vector2F},
     },
     json::{json, ToJson},
-    LayoutContext, PaintContext, SceneBuilder, View, ViewContext,
+    LayoutContext, PaintContext, SceneBuilder, ViewContext,
 };
 use crate::{Element, SizeConstraint};
 
@@ -26,7 +26,7 @@ impl Empty {
     }
 }
 
-impl<V: View> Element<V> for Empty {
+impl<V: 'static> Element<V> for Empty {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/expanded.rs b/crates/gpui/src/elements/expanded.rs
index 1f4f2f40a1..ad6682d2a9 100644
--- a/crates/gpui/src/elements/expanded.rs
+++ b/crates/gpui/src/elements/expanded.rs
@@ -2,18 +2,18 @@ use std::ops::Range;
 
 use crate::{
     geometry::{rect::RectF, vector::Vector2F},
-    json, AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, View,
+    json, AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint,
     ViewContext,
 };
 use serde_json::json;
 
-pub struct Expanded<V: View> {
+pub struct Expanded<V> {
     child: AnyElement<V>,
     full_width: bool,
     full_height: bool,
 }
 
-impl<V: View> Expanded<V> {
+impl<V: 'static> Expanded<V> {
     pub fn new(child: impl Element<V>) -> Self {
         Self {
             child: child.into_any(),
@@ -35,7 +35,7 @@ impl<V: View> Expanded<V> {
     }
 }
 
-impl<V: View> Element<V> for Expanded<V> {
+impl<V: 'static> Element<V> for Expanded<V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/flex.rs b/crates/gpui/src/elements/flex.rs
index 3000b9575d..d9c43ca4c8 100644
--- a/crates/gpui/src/elements/flex.rs
+++ b/crates/gpui/src/elements/flex.rs
@@ -3,7 +3,7 @@ use std::{any::Any, cell::Cell, f32::INFINITY, ops::Range, rc::Rc};
 use crate::{
     json::{self, ToJson, Value},
     AnyElement, Axis, Element, ElementStateHandle, LayoutContext, PaintContext, SceneBuilder,
-    SizeConstraint, Vector2FExt, View, ViewContext,
+    SizeConstraint, Vector2FExt, ViewContext,
 };
 use pathfinder_geometry::{
     rect::RectF,
@@ -17,14 +17,14 @@ struct ScrollState {
     scroll_position: Cell<f32>,
 }
 
-pub struct Flex<V: View> {
+pub struct Flex<V> {
     axis: Axis,
     children: Vec<AnyElement<V>>,
     scroll_state: Option<(ElementStateHandle<Rc<ScrollState>>, usize)>,
     child_alignment: f32,
 }
 
-impl<V: View> Flex<V> {
+impl<V: 'static> Flex<V> {
     pub fn new(axis: Axis) -> Self {
         Self {
             axis,
@@ -115,13 +115,13 @@ impl<V: View> Flex<V> {
     }
 }
 
-impl<V: View> Extend<AnyElement<V>> for Flex<V> {
+impl<V> Extend<AnyElement<V>> for Flex<V> {
     fn extend<T: IntoIterator<Item = AnyElement<V>>>(&mut self, children: T) {
         self.children.extend(children);
     }
 }
 
-impl<V: View> Element<V> for Flex<V> {
+impl<V: 'static> Element<V> for Flex<V> {
     type LayoutState = f32;
     type PaintState = ();
 
@@ -401,12 +401,12 @@ struct FlexParentData {
     float: bool,
 }
 
-pub struct FlexItem<V: View> {
+pub struct FlexItem<V> {
     metadata: FlexParentData,
     child: AnyElement<V>,
 }
 
-impl<V: View> FlexItem<V> {
+impl<V: 'static> FlexItem<V> {
     pub fn new(child: impl Element<V>) -> Self {
         FlexItem {
             metadata: FlexParentData {
@@ -428,7 +428,7 @@ impl<V: View> FlexItem<V> {
     }
 }
 
-impl<V: View> Element<V> for FlexItem<V> {
+impl<V: 'static> Element<V> for FlexItem<V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/hook.rs b/crates/gpui/src/elements/hook.rs
index 7ac6c95f3e..579c2b682f 100644
--- a/crates/gpui/src/elements/hook.rs
+++ b/crates/gpui/src/elements/hook.rs
@@ -3,16 +3,15 @@ use std::ops::Range;
 use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::json,
-    AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, View,
-    ViewContext,
+    AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, ViewContext,
 };
 
-pub struct Hook<V: View> {
+pub struct Hook<V> {
     child: AnyElement<V>,
     after_layout: Option<Box<dyn FnMut(Vector2F, &mut ViewContext<V>)>>,
 }
 
-impl<V: View> Hook<V> {
+impl<V: 'static> Hook<V> {
     pub fn new(child: impl Element<V>) -> Self {
         Self {
             child: child.into_any(),
@@ -29,7 +28,7 @@ impl<V: View> Hook<V> {
     }
 }
 
-impl<V: View> Element<V> for Hook<V> {
+impl<V: 'static> Element<V> for Hook<V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/image.rs b/crates/gpui/src/elements/image.rs
index e87c065917..339ece4764 100644
--- a/crates/gpui/src/elements/image.rs
+++ b/crates/gpui/src/elements/image.rs
@@ -6,7 +6,7 @@ use crate::{
     },
     json::{json, ToJson},
     scene, Border, Element, ImageData, LayoutContext, PaintContext, SceneBuilder, SizeConstraint,
-    View, ViewContext,
+    ViewContext,
 };
 use schemars::JsonSchema;
 use serde::Deserialize;
@@ -57,7 +57,7 @@ impl Image {
     }
 }
 
-impl<V: View> Element<V> for Image {
+impl<V: 'static> Element<V> for Image {
     type LayoutState = Option<Arc<ImageData>>;
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/keystroke_label.rs b/crates/gpui/src/elements/keystroke_label.rs
index 268f3ccb1c..48a3971658 100644
--- a/crates/gpui/src/elements/keystroke_label.rs
+++ b/crates/gpui/src/elements/keystroke_label.rs
@@ -31,7 +31,7 @@ impl KeystrokeLabel {
     }
 }
 
-impl<V: View> Element<V> for KeystrokeLabel {
+impl<V: 'static> Element<V> for KeystrokeLabel {
     type LayoutState = AnyElement<V>;
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/label.rs b/crates/gpui/src/elements/label.rs
index 80555c7442..281c2ce9b8 100644
--- a/crates/gpui/src/elements/label.rs
+++ b/crates/gpui/src/elements/label.rs
@@ -8,7 +8,7 @@ use crate::{
     },
     json::{ToJson, Value},
     text_layout::{Line, RunStyle},
-    Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, View, ViewContext,
+    Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, ViewContext,
 };
 use schemars::JsonSchema;
 use serde::Deserialize;
@@ -128,7 +128,7 @@ impl Label {
     }
 }
 
-impl<V: View> Element<V> for Label {
+impl<V: 'static> Element<V> for Label {
     type LayoutState = Line;
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/list.rs b/crates/gpui/src/elements/list.rs
index 5454519905..fd035891a1 100644
--- a/crates/gpui/src/elements/list.rs
+++ b/crates/gpui/src/elements/list.rs
@@ -5,16 +5,16 @@ use crate::{
     },
     json::json,
     AnyElement, Element, LayoutContext, MouseRegion, PaintContext, SceneBuilder, SizeConstraint,
-    View, ViewContext,
+    ViewContext,
 };
 use std::{cell::RefCell, collections::VecDeque, fmt::Debug, ops::Range, rc::Rc};
 use sum_tree::{Bias, SumTree};
 
-pub struct List<V: View> {
+pub struct List<V> {
     state: ListState<V>,
 }
 
-pub struct ListState<V: View>(Rc<RefCell<StateInner<V>>>);
+pub struct ListState<V>(Rc<RefCell<StateInner<V>>>);
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Orientation {
@@ -22,7 +22,7 @@ pub enum Orientation {
     Bottom,
 }
 
-struct StateInner<V: View> {
+struct StateInner<V> {
     last_layout_width: Option<f32>,
     render_item: Box<dyn FnMut(&mut V, usize, &mut ViewContext<V>) -> AnyElement<V>>,
     rendered_range: Range<usize>,
@@ -40,13 +40,13 @@ pub struct ListOffset {
     pub offset_in_item: f32,
 }
 
-enum ListItem<V: View> {
+enum ListItem<V> {
     Unrendered,
     Rendered(Rc<RefCell<AnyElement<V>>>),
     Removed(f32),
 }
 
-impl<V: View> Clone for ListItem<V> {
+impl<V> Clone for ListItem<V> {
     fn clone(&self) -> Self {
         match self {
             Self::Unrendered => Self::Unrendered,
@@ -56,7 +56,7 @@ impl<V: View> Clone for ListItem<V> {
     }
 }
 
-impl<V: View> Debug for ListItem<V> {
+impl<V> Debug for ListItem<V> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Unrendered => write!(f, "Unrendered"),
@@ -86,13 +86,13 @@ struct UnrenderedCount(usize);
 #[derive(Clone, Debug, Default)]
 struct Height(f32);
 
-impl<V: View> List<V> {
+impl<V> List<V> {
     pub fn new(state: ListState<V>) -> Self {
         Self { state }
     }
 }
 
-impl<V: View> Element<V> for List<V> {
+impl<V: 'static> Element<V> for List<V> {
     type LayoutState = ListOffset;
     type PaintState = ();
 
@@ -347,7 +347,7 @@ impl<V: View> Element<V> for List<V> {
     }
 }
 
-impl<V: View> ListState<V> {
+impl<V: 'static> ListState<V> {
     pub fn new<D, F>(
         element_count: usize,
         orientation: Orientation,
@@ -440,13 +440,13 @@ impl<V: View> ListState<V> {
     }
 }
 
-impl<V: View> Clone for ListState<V> {
+impl<V> Clone for ListState<V> {
     fn clone(&self) -> Self {
         Self(self.0.clone())
     }
 }
 
-impl<V: View> StateInner<V> {
+impl<V: 'static> StateInner<V> {
     fn render_item(
         &mut self,
         ix: usize,
@@ -560,7 +560,7 @@ impl<V: View> StateInner<V> {
     }
 }
 
-impl<V: View> ListItem<V> {
+impl<V> ListItem<V> {
     fn remove(&self) -> Self {
         match self {
             ListItem::Unrendered => ListItem::Unrendered,
@@ -570,7 +570,7 @@ impl<V: View> ListItem<V> {
     }
 }
 
-impl<V: View> sum_tree::Item for ListItem<V> {
+impl<V> sum_tree::Item for ListItem<V> {
     type Summary = ListItemSummary;
 
     fn summary(&self) -> Self::Summary {
@@ -944,7 +944,7 @@ mod tests {
         type Event = ();
     }
 
-    impl View for TestView {
+    impl crate::View for TestView {
         fn ui_name() -> &'static str {
             "TestView"
         }
@@ -968,7 +968,7 @@ mod tests {
         }
     }
 
-    impl<V: View> Element<V> for TestElement {
+    impl<V: 'static> Element<V> for TestElement {
         type LayoutState = ();
         type PaintState = ();
 
diff --git a/crates/gpui/src/elements/mouse_event_handler.rs b/crates/gpui/src/elements/mouse_event_handler.rs
index 6005277f73..be773fd4b1 100644
--- a/crates/gpui/src/elements/mouse_event_handler.rs
+++ b/crates/gpui/src/elements/mouse_event_handler.rs
@@ -11,12 +11,12 @@ use crate::{
         MouseHover, MouseMove, MouseMoveOut, MouseScrollWheel, MouseUp, MouseUpOut,
     },
     AnyElement, Element, EventContext, LayoutContext, MouseRegion, MouseState, PaintContext,
-    SceneBuilder, SizeConstraint, View, ViewContext,
+    SceneBuilder, SizeConstraint, ViewContext,
 };
 use serde_json::json;
 use std::{marker::PhantomData, ops::Range};
 
-pub struct MouseEventHandler<Tag: 'static, V: View> {
+pub struct MouseEventHandler<Tag: 'static, V> {
     child: AnyElement<V>,
     region_id: usize,
     cursor_style: Option<CursorStyle>,
@@ -31,7 +31,7 @@ pub struct MouseEventHandler<Tag: 'static, V: View> {
 
 /// Element which provides a render_child callback with a MouseState and paints a mouse
 /// region under (or above) it for easy mouse event handling.
-impl<Tag, V: View> MouseEventHandler<Tag, V> {
+impl<Tag, V: 'static> MouseEventHandler<Tag, V> {
     pub fn for_child(child: impl Element<V>, region_id: usize) -> Self {
         Self {
             child: child.into_any(),
@@ -236,7 +236,7 @@ impl<Tag, V: View> MouseEventHandler<Tag, V> {
     }
 }
 
-impl<Tag, V: View> Element<V> for MouseEventHandler<Tag, V> {
+impl<Tag, V: 'static> Element<V> for MouseEventHandler<Tag, V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/overlay.rs b/crates/gpui/src/elements/overlay.rs
index 56e3d10de3..14d19e802c 100644
--- a/crates/gpui/src/elements/overlay.rs
+++ b/crates/gpui/src/elements/overlay.rs
@@ -4,11 +4,11 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::ToJson,
     AnyElement, Axis, Element, LayoutContext, MouseRegion, PaintContext, SceneBuilder,
-    SizeConstraint, View, ViewContext,
+    SizeConstraint, ViewContext,
 };
 use serde_json::json;
 
-pub struct Overlay<V: View> {
+pub struct Overlay<V> {
     child: AnyElement<V>,
     anchor_position: Option<Vector2F>,
     anchor_corner: AnchorCorner,
@@ -73,7 +73,7 @@ impl AnchorCorner {
     }
 }
 
-impl<V: View> Overlay<V> {
+impl<V: 'static> Overlay<V> {
     pub fn new(child: impl Element<V>) -> Self {
         Self {
             child: child.into_any(),
@@ -117,7 +117,7 @@ impl<V: View> Overlay<V> {
     }
 }
 
-impl<V: View> Element<V> for Overlay<V> {
+impl<V: 'static> Element<V> for Overlay<V> {
     type LayoutState = Vector2F;
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/resizable.rs b/crates/gpui/src/elements/resizable.rs
index 0b1d94f8f8..00b0bb1e69 100644
--- a/crates/gpui/src/elements/resizable.rs
+++ b/crates/gpui/src/elements/resizable.rs
@@ -8,7 +8,7 @@ use crate::{
     platform::{CursorStyle, MouseButton},
     scene::MouseDrag,
     AnyElement, Axis, Element, LayoutContext, MouseRegion, PaintContext, SceneBuilder,
-    SizeConstraint, View, ViewContext,
+    SizeConstraint, ViewContext,
 };
 
 #[derive(Copy, Clone, Debug)]
@@ -69,7 +69,7 @@ impl HandleSide {
     }
 }
 
-pub struct Resizable<V: View> {
+pub struct Resizable<V> {
     child: AnyElement<V>,
     handle_side: HandleSide,
     handle_size: f32,
@@ -78,7 +78,7 @@ pub struct Resizable<V: View> {
 
 const DEFAULT_HANDLE_SIZE: f32 = 4.0;
 
-impl<V: View> Resizable<V> {
+impl<V: 'static> Resizable<V> {
     pub fn new(
         child: AnyElement<V>,
         handle_side: HandleSide,
@@ -105,7 +105,7 @@ impl<V: View> Resizable<V> {
     }
 }
 
-impl<V: View> Element<V> for Resizable<V> {
+impl<V: 'static> Element<V> for Resizable<V> {
     type LayoutState = SizeConstraint;
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/stack.rs b/crates/gpui/src/elements/stack.rs
index 8f9d1e4d05..e73e2f0b40 100644
--- a/crates/gpui/src/elements/stack.rs
+++ b/crates/gpui/src/elements/stack.rs
@@ -3,17 +3,16 @@ use std::ops::Range;
 use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::{self, json, ToJson},
-    AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, View,
-    ViewContext,
+    AnyElement, Element, LayoutContext, PaintContext, SceneBuilder, SizeConstraint, ViewContext,
 };
 
 /// Element which renders it's children in a stack on top of each other.
 /// The first child determines the size of the others.
-pub struct Stack<V: View> {
+pub struct Stack<V> {
     children: Vec<AnyElement<V>>,
 }
 
-impl<V: View> Default for Stack<V> {
+impl<V> Default for Stack<V> {
     fn default() -> Self {
         Self {
             children: Vec::new(),
@@ -21,13 +20,13 @@ impl<V: View> Default for Stack<V> {
     }
 }
 
-impl<V: View> Stack<V> {
+impl<V> Stack<V> {
     pub fn new() -> Self {
         Self::default()
     }
 }
 
-impl<V: View> Element<V> for Stack<V> {
+impl<V: 'static> Element<V> for Stack<V> {
     type LayoutState = ();
     type PaintState = ();
 
@@ -99,7 +98,7 @@ impl<V: View> Element<V> for Stack<V> {
     }
 }
 
-impl<V: View> Extend<AnyElement<V>> for Stack<V> {
+impl<V> Extend<AnyElement<V>> for Stack<V> {
     fn extend<T: IntoIterator<Item = AnyElement<V>>>(&mut self, children: T) {
         self.children.extend(children)
     }
diff --git a/crates/gpui/src/elements/svg.rs b/crates/gpui/src/elements/svg.rs
index c4d58cd7a7..0d5bcd59e4 100644
--- a/crates/gpui/src/elements/svg.rs
+++ b/crates/gpui/src/elements/svg.rs
@@ -7,7 +7,7 @@ use crate::{
         rect::RectF,
         vector::{vec2f, Vector2F},
     },
-    scene, Element, LayoutContext, SceneBuilder, SizeConstraint, View, ViewContext,
+    scene, Element, LayoutContext, SceneBuilder, SizeConstraint, ViewContext,
 };
 use schemars::JsonSchema;
 use serde_derive::Deserialize;
@@ -27,7 +27,7 @@ impl Svg {
         }
     }
 
-    pub fn for_style<V: View>(style: SvgStyle) -> impl Element<V> {
+    pub fn for_style<V: 'static>(style: SvgStyle) -> impl Element<V> {
         Self::new(style.asset)
             .with_color(style.color)
             .constrained()
@@ -41,7 +41,7 @@ impl Svg {
     }
 }
 
-impl<V: View> Element<V> for Svg {
+impl<V: 'static> Element<V> for Svg {
     type LayoutState = Option<usvg::Tree>;
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/text.rs b/crates/gpui/src/elements/text.rs
index 9357c31f19..a1fca07a8b 100644
--- a/crates/gpui/src/elements/text.rs
+++ b/crates/gpui/src/elements/text.rs
@@ -8,7 +8,7 @@ use crate::{
     json::{ToJson, Value},
     text_layout::{Line, RunStyle, ShapedBoundary},
     AppContext, Element, FontCache, LayoutContext, PaintContext, SceneBuilder, SizeConstraint,
-    TextLayoutCache, View, ViewContext,
+    TextLayoutCache, ViewContext,
 };
 use log::warn;
 use serde_json::json;
@@ -70,7 +70,7 @@ impl Text {
     }
 }
 
-impl<V: View> Element<V> for Text {
+impl<V: 'static> Element<V> for Text {
     type LayoutState = LayoutState;
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/tooltip.rs b/crates/gpui/src/elements/tooltip.rs
index 0510baa9e4..9189d6da0e 100644
--- a/crates/gpui/src/elements/tooltip.rs
+++ b/crates/gpui/src/elements/tooltip.rs
@@ -7,7 +7,7 @@ use crate::{
     geometry::{rect::RectF, vector::Vector2F},
     json::json,
     Action, Axis, ElementStateHandle, LayoutContext, PaintContext, SceneBuilder, SizeConstraint,
-    Task, View, ViewContext,
+    Task, ViewContext,
 };
 use schemars::JsonSchema;
 use serde::Deserialize;
@@ -21,7 +21,7 @@ use util::ResultExt;
 
 const DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(500);
 
-pub struct Tooltip<V: View> {
+pub struct Tooltip<V> {
     child: AnyElement<V>,
     tooltip: Option<AnyElement<V>>,
     _state: ElementStateHandle<Rc<TooltipState>>,
@@ -51,8 +51,8 @@ pub struct KeystrokeStyle {
     text: TextStyle,
 }
 
-impl<V: View> Tooltip<V> {
-    pub fn new<Tag: 'static, T: View>(
+impl<V: 'static> Tooltip<V> {
+    pub fn new<Tag: 'static, T: 'static>(
         id: usize,
         text: String,
         action: Option<Box<dyn Action>>,
@@ -166,7 +166,7 @@ impl<V: View> Tooltip<V> {
     }
 }
 
-impl<V: View> Element<V> for Tooltip<V> {
+impl<V: 'static> Element<V> for Tooltip<V> {
     type LayoutState = ();
     type PaintState = ();
 
diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs
index b9bfadb17f..c7279d6389 100644
--- a/crates/gpui/src/elements/uniform_list.rs
+++ b/crates/gpui/src/elements/uniform_list.rs
@@ -6,7 +6,7 @@ use crate::{
     },
     json::{self, json},
     platform::ScrollWheelEvent,
-    AnyElement, LayoutContext, MouseRegion, PaintContext, SceneBuilder, View, ViewContext,
+    AnyElement, LayoutContext, MouseRegion, PaintContext, SceneBuilder, ViewContext,
 };
 use json::ToJson;
 use std::{cell::RefCell, cmp, ops::Range, rc::Rc};
@@ -36,13 +36,13 @@ struct StateInner {
     scroll_to: Option<ScrollTarget>,
 }
 
-pub struct UniformListLayoutState<V: View> {
+pub struct UniformListLayoutState<V> {
     scroll_max: f32,
     item_height: f32,
     items: Vec<AnyElement<V>>,
 }
 
-pub struct UniformList<V: View> {
+pub struct UniformList<V> {
     state: UniformListState,
     item_count: usize,
     #[allow(clippy::type_complexity)]
@@ -53,7 +53,7 @@ pub struct UniformList<V: View> {
     view_id: usize,
 }
 
-impl<V: View> UniformList<V> {
+impl<V: 'static> UniformList<V> {
     pub fn new<F>(
         state: UniformListState,
         item_count: usize,
@@ -61,7 +61,6 @@ impl<V: View> UniformList<V> {
         append_items: F,
     ) -> Self
     where
-        V: View,
         F: 'static + Fn(&mut V, Range<usize>, &mut Vec<AnyElement<V>>, &mut ViewContext<V>),
     {
         Self {
@@ -151,7 +150,7 @@ impl<V: View> UniformList<V> {
     }
 }
 
-impl<V: View> Element<V> for UniformList<V> {
+impl<V: 'static> Element<V> for UniformList<V> {
     type LayoutState = UniformListLayoutState<V>;
     type PaintState = ();
 
diff --git a/crates/gpui/src/scene/mouse_region.rs b/crates/gpui/src/scene/mouse_region.rs
index cf39ac782f..a0277a9432 100644
--- a/crates/gpui/src/scene/mouse_region.rs
+++ b/crates/gpui/src/scene/mouse_region.rs
@@ -1,4 +1,4 @@
-use crate::{platform::MouseButton, window::WindowContext, EventContext, View, ViewContext};
+use crate::{platform::MouseButton, window::WindowContext, EventContext, ViewContext};
 use collections::HashMap;
 use pathfinder_geometry::rect::RectF;
 use smallvec::SmallVec;
@@ -64,7 +64,7 @@ impl MouseRegion {
 
     pub fn on_down<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseDown, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_down(button, handler);
@@ -73,7 +73,7 @@ impl MouseRegion {
 
     pub fn on_up<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseUp, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_up(button, handler);
@@ -82,7 +82,7 @@ impl MouseRegion {
 
     pub fn on_click<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseClick, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_click(button, handler);
@@ -91,7 +91,7 @@ impl MouseRegion {
 
     pub fn on_click_out<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseClickOut, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_click_out(button, handler);
@@ -100,7 +100,7 @@ impl MouseRegion {
 
     pub fn on_down_out<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseDownOut, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_down_out(button, handler);
@@ -109,7 +109,7 @@ impl MouseRegion {
 
     pub fn on_up_out<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseUpOut, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_up_out(button, handler);
@@ -118,7 +118,7 @@ impl MouseRegion {
 
     pub fn on_drag<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseDrag, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_drag(button, handler);
@@ -127,7 +127,7 @@ impl MouseRegion {
 
     pub fn on_hover<V, F>(mut self, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseHover, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_hover(handler);
@@ -136,7 +136,7 @@ impl MouseRegion {
 
     pub fn on_move<V, F>(mut self, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseMove, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_move(handler);
@@ -145,7 +145,7 @@ impl MouseRegion {
 
     pub fn on_move_out<V, F>(mut self, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseMoveOut, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_move_out(handler);
@@ -154,7 +154,7 @@ impl MouseRegion {
 
     pub fn on_scroll<V, F>(mut self, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseScrollWheel, &mut V, &mut EventContext<V>) + 'static,
     {
         self.handlers = self.handlers.on_scroll(handler);
@@ -310,7 +310,7 @@ impl HandlerSet {
 
     pub fn on_move<V, F>(mut self, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseMove, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::move_disc(), None,
@@ -332,7 +332,7 @@ impl HandlerSet {
 
     pub fn on_move_out<V, F>(mut self, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseMoveOut, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::move_out_disc(), None,
@@ -354,7 +354,7 @@ impl HandlerSet {
 
     pub fn on_down<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseDown, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::down_disc(), Some(button),
@@ -376,7 +376,7 @@ impl HandlerSet {
 
     pub fn on_up<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseUp, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::up_disc(), Some(button),
@@ -398,7 +398,7 @@ impl HandlerSet {
 
     pub fn on_click<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseClick, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::click_disc(), Some(button),
@@ -420,7 +420,7 @@ impl HandlerSet {
 
     pub fn on_click_out<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseClickOut, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::click_out_disc(), Some(button),
@@ -442,7 +442,7 @@ impl HandlerSet {
 
     pub fn on_down_out<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseDownOut, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::down_out_disc(), Some(button),
@@ -464,7 +464,7 @@ impl HandlerSet {
 
     pub fn on_up_out<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseUpOut, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::up_out_disc(), Some(button),
@@ -486,7 +486,7 @@ impl HandlerSet {
 
     pub fn on_drag<V, F>(mut self, button: MouseButton, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseDrag, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::drag_disc(), Some(button),
@@ -508,7 +508,7 @@ impl HandlerSet {
 
     pub fn on_hover<V, F>(mut self, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseHover, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::hover_disc(), None,
@@ -530,7 +530,7 @@ impl HandlerSet {
 
     pub fn on_scroll<V, F>(mut self, handler: F) -> Self
     where
-        V: View,
+        V: 'static,
         F: Fn(MouseScrollWheel, &mut V, &mut EventContext<V>) + 'static,
     {
         self.insert(MouseEvent::scroll_wheel_disc(), None,
diff --git a/crates/language_tools/src/lsp_log.rs b/crates/language_tools/src/lsp_log.rs
index 0dc594a13f..de410b6211 100644
--- a/crates/language_tools/src/lsp_log.rs
+++ b/crates/language_tools/src/lsp_log.rs
@@ -450,7 +450,7 @@ impl View for LspLogView {
 }
 
 impl Item for LspLogView {
-    fn tab_content<V: View>(
+    fn tab_content<V: 'static>(
         &self,
         _: Option<usize>,
         style: &theme::Tab,
diff --git a/crates/language_tools/src/syntax_tree_view.rs b/crates/language_tools/src/syntax_tree_view.rs
index 3e6727bbf4..fd12f88a9d 100644
--- a/crates/language_tools/src/syntax_tree_view.rs
+++ b/crates/language_tools/src/syntax_tree_view.rs
@@ -451,7 +451,7 @@ impl View for SyntaxTreeView {
 }
 
 impl Item for SyntaxTreeView {
-    fn tab_content<V: View>(
+    fn tab_content<V: 'static>(
         &self,
         _: Option<usize>,
         style: &theme::Tab,
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index f7582f1764..79784516ed 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -1320,7 +1320,7 @@ impl ProjectPanel {
         }
     }
 
-    fn render_entry_visual_element<V: View>(
+    fn render_entry_visual_element<V: 'static>(
         details: &EntryDetails,
         editor: Option<&ViewHandle<Editor>>,
         padding: f32,
diff --git a/crates/recent_projects/src/highlighted_workspace_location.rs b/crates/recent_projects/src/highlighted_workspace_location.rs
index f915cb24ed..79c7ddec18 100644
--- a/crates/recent_projects/src/highlighted_workspace_location.rs
+++ b/crates/recent_projects/src/highlighted_workspace_location.rs
@@ -3,7 +3,7 @@ use std::path::Path;
 use fuzzy::StringMatch;
 use gpui::{
     elements::{Label, LabelStyle},
-    AnyElement, Element, View,
+    AnyElement, Element,
 };
 use util::paths::PathExt;
 use workspace::WorkspaceLocation;
@@ -43,7 +43,7 @@ impl HighlightedText {
         }
     }
 
-    pub fn render<V: View>(self, style: impl Into<LabelStyle>) -> AnyElement<V> {
+    pub fn render<V: 'static>(self, style: impl Into<LabelStyle>) -> AnyElement<V> {
         Label::new(self.text, style)
             .with_highlights(self.highlight_positions)
             .into_any()
diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index 018ab9cb11..f6b3976f44 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -395,7 +395,7 @@ impl Item for ProjectSearchView {
             .update(cx, |editor, cx| editor.deactivated(cx));
     }
 
-    fn tab_content<T: View>(
+    fn tab_content<T: 'static>(
         &self,
         _detail: Option<usize>,
         tab_theme: &theme::Tab,
diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index 970e0115df..99f7d6332d 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -657,7 +657,7 @@ impl Item for TerminalView {
         Some(self.terminal().read(cx).title().into())
     }
 
-    fn tab_content<T: View>(
+    fn tab_content<T: 'static>(
         &self,
         _detail: Option<usize>,
         tab_theme: &theme::Tab,
diff --git a/crates/theme/src/ui.rs b/crates/theme/src/ui.rs
index a16c3cb21e..bd9af52d0e 100644
--- a/crates/theme/src/ui.rs
+++ b/crates/theme/src/ui.rs
@@ -10,7 +10,7 @@ use gpui::{
     platform,
     platform::MouseButton,
     scene::MouseClick,
-    Action, Element, EventContext, MouseState, View, ViewContext,
+    Action, Element, EventContext, MouseState, ViewContext,
 };
 use schemars::JsonSchema;
 use serde::Deserialize;
@@ -37,7 +37,7 @@ pub fn checkbox<Tag, V, F>(
 ) -> MouseEventHandler<Tag, V>
 where
     Tag: 'static,
-    V: View,
+    V: 'static,
     F: 'static + Fn(&mut V, bool, &mut EventContext<V>),
 {
     let label = Label::new(label, style.label.text.clone())
@@ -57,7 +57,7 @@ pub fn checkbox_with_label<Tag, D, V, F>(
 where
     Tag: 'static,
     D: Element<V>,
-    V: View,
+    V: 'static,
     F: 'static + Fn(&mut V, bool, &mut EventContext<V>),
 {
     MouseEventHandler::new(id, cx, |state, _| {
@@ -93,7 +93,7 @@ where
     .with_cursor_style(platform::CursorStyle::PointingHand)
 }
 
-pub fn svg<V: View>(style: &SvgStyle) -> ConstrainedBox<V> {
+pub fn svg<V: 'static>(style: &SvgStyle) -> ConstrainedBox<V> {
     Svg::new(style.asset.clone())
         .with_color(style.color)
         .constrained()
@@ -107,11 +107,11 @@ pub struct IconStyle {
     pub container: ContainerStyle,
 }
 
-pub fn icon<V: View>(style: &IconStyle) -> Container<V> {
+pub fn icon<V: 'static>(style: &IconStyle) -> Container<V> {
     svg(&style.icon).contained().with_style(style.container)
 }
 
-pub fn keystroke_label<V: View>(
+pub fn keystroke_label<V: 'static>(
     label_text: &'static str,
     label_style: &ContainedText,
     keystroke_style: &ContainedText,
@@ -147,7 +147,7 @@ pub fn cta_button<Tag, L, V, F>(
 where
     Tag: 'static,
     L: Into<Cow<'static, str>>,
-    V: View,
+    V: 'static,
     F: Fn(MouseClick, &mut V, &mut EventContext<V>) + 'static,
 {
     MouseEventHandler::<Tag, V>::new(0, cx, |state, _| {
@@ -186,9 +186,9 @@ pub fn modal<Tag, V, I, D, F>(
 ) -> impl Element<V>
 where
     Tag: 'static,
-    V: View,
     I: Into<Cow<'static, str>>,
     D: Element<V>,
+    V: 'static,
     F: FnOnce(&mut gpui::ViewContext<V>) -> D,
 {
     const TITLEBAR_HEIGHT: f32 = 28.;
diff --git a/crates/welcome/src/welcome.rs b/crates/welcome/src/welcome.rs
index b7460c4c46..4d8df53a1b 100644
--- a/crates/welcome/src/welcome.rs
+++ b/crates/welcome/src/welcome.rs
@@ -232,7 +232,7 @@ impl Item for WelcomePage {
         Some("Welcome to Zed!".into())
     }
 
-    fn tab_content<T: View>(
+    fn tab_content<T: 'static>(
         &self,
         _detail: Option<usize>,
         style: &theme::Tab,
diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs
index 21956be446..a115e0f473 100644
--- a/crates/workspace/src/item.rs
+++ b/crates/workspace/src/item.rs
@@ -101,7 +101,7 @@ pub trait Item: View {
     fn tab_description<'a>(&'a self, _: usize, _: &'a AppContext) -> Option<Cow<str>> {
         None
     }
-    fn tab_content<V: View>(
+    fn tab_content<V: 'static>(
         &self,
         detail: Option<usize>,
         style: &theme::Tab,
@@ -943,7 +943,7 @@ pub mod test {
             })
         }
 
-        fn tab_content<V: View>(
+        fn tab_content<V: 'static>(
             &self,
             detail: Option<usize>,
             _: &theme::Tab,
diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index 8064478964..f51c2baf68 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -1864,12 +1864,12 @@ impl NavHistoryState {
     }
 }
 
-pub struct PaneBackdrop<V: View> {
+pub struct PaneBackdrop<V> {
     child_view: usize,
     child: AnyElement<V>,
 }
 
-impl<V: View> PaneBackdrop<V> {
+impl<V> PaneBackdrop<V> {
     pub fn new(pane_item_view: usize, child: AnyElement<V>) -> Self {
         PaneBackdrop {
             child,
@@ -1878,7 +1878,7 @@ impl<V: View> PaneBackdrop<V> {
     }
 }
 
-impl<V: View> Element<V> for PaneBackdrop<V> {
+impl<V: 'static> Element<V> for PaneBackdrop<V> {
     type LayoutState = ();
 
     type PaintState = ();
diff --git a/crates/workspace/src/pane/dragged_item_receiver.rs b/crates/workspace/src/pane/dragged_item_receiver.rs
index 2d3fe8ea83..8208b4b3d5 100644
--- a/crates/workspace/src/pane/dragged_item_receiver.rs
+++ b/crates/workspace/src/pane/dragged_item_receiver.rs
@@ -7,7 +7,7 @@ use gpui::{
     geometry::{rect::RectF, vector::Vector2F},
     platform::MouseButton,
     scene::MouseUp,
-    AppContext, Element, EventContext, MouseState, Quad, View, ViewContext, WeakViewHandle,
+    AppContext, Element, EventContext, MouseState, Quad, ViewContext, WeakViewHandle,
 };
 use project::ProjectEntryId;
 
@@ -107,7 +107,7 @@ where
     handler
 }
 
-pub fn handle_dropped_item<V: View>(
+pub fn handle_dropped_item<V: 'static>(
     event: MouseUp,
     workspace: WeakViewHandle<Workspace>,
     pane: &WeakViewHandle<Pane>,
diff --git a/crates/workspace/src/shared_screen.rs b/crates/workspace/src/shared_screen.rs
index 977e167f60..00f422de4e 100644
--- a/crates/workspace/src/shared_screen.rs
+++ b/crates/workspace/src/shared_screen.rs
@@ -104,7 +104,7 @@ impl Item for SharedScreen {
         }
     }
 
-    fn tab_content<V: View>(
+    fn tab_content<V: 'static>(
         &self,
         _: Option<usize>,
         style: &theme::Tab,