krisyotam/zed

Cargo.lock+2−0

  "serde_json",
  "settings",
  "smallvec",
+ "story",
  "theme",
  "theme_selector",
  "time",
  "backtrace-on-stack-overflow",
  "chrono",
  "clap 4.4.4",
+ "collab_ui",
  "dialoguer",
  "editor",
  "fuzzy",

crates/assistant/src/assistant_panel.rs+17−17

@@ -933,7 +933,7 @@ impl AssistantPanel { · 932 unmodified lines
933	}	933	}
934		934
935	fn render_hamburger_button(cx: &mut ViewContext<Self>) -> impl IntoElement {	935	fn render_hamburger_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
936	IconButton::new("hamburger_button", Icon::Menu)	936	IconButton::new("hamburger_button", IconName::Menu)
937	.on_click(cx.listener(\|this, _event, cx\| {	937	.on_click(cx.listener(\|this, _event, cx\| {
938	if this.active_editor().is_some() {	938	if this.active_editor().is_some() {
939	this.set_active_editor_index(None, cx);	939	this.set_active_editor_index(None, cx);
@@ -957,7 +957,7 @@ impl AssistantPanel { · 17 unmodified lines
957	}	957	}
958		958
959	fn render_split_button(cx: &mut ViewContext<Self>) -> impl IntoElement {	959	fn render_split_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
960	IconButton::new("split_button", Icon::Snip)	960	IconButton::new("split_button", IconName::Snip)
961	.on_click(cx.listener(\|this, _event, cx\| {	961	.on_click(cx.listener(\|this, _event, cx\| {
962	if let Some(active_editor) = this.active_editor() {	962	if let Some(active_editor) = this.active_editor() {
963	active_editor.update(cx, \|editor, cx\| editor.split(&Default::default(), cx));	963	active_editor.update(cx, \|editor, cx\| editor.split(&Default::default(), cx));
@@ -968,7 +968,7 @@ impl AssistantPanel { · 4 unmodified lines
968	}	968	}
969		969
970	fn render_assist_button(cx: &mut ViewContext<Self>) -> impl IntoElement {	970	fn render_assist_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
971	IconButton::new("assist_button", Icon::MagicWand)	971	IconButton::new("assist_button", IconName::MagicWand)
972	.on_click(cx.listener(\|this, _event, cx\| {	972	.on_click(cx.listener(\|this, _event, cx\| {
973	if let Some(active_editor) = this.active_editor() {	973	if let Some(active_editor) = this.active_editor() {
974	active_editor.update(cx, \|editor, cx\| editor.assist(&Default::default(), cx));	974	active_editor.update(cx, \|editor, cx\| editor.assist(&Default::default(), cx));
@@ -979,7 +979,7 @@ impl AssistantPanel { · 4 unmodified lines
979	}	979	}
980		980
981	fn render_quote_button(cx: &mut ViewContext<Self>) -> impl IntoElement {	981	fn render_quote_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
982	IconButton::new("quote_button", Icon::Quote)	982	IconButton::new("quote_button", IconName::Quote)
983	.on_click(cx.listener(\|this, _event, cx\| {	983	.on_click(cx.listener(\|this, _event, cx\| {
984	if let Some(workspace) = this.workspace.upgrade() {	984	if let Some(workspace) = this.workspace.upgrade() {
985	cx.window_context().defer(move \|cx\| {	985	cx.window_context().defer(move \|cx\| {
@@ -994,7 +994,7 @@ impl AssistantPanel { · 8 unmodified lines
994	}	994	}
995		995
996	fn render_plus_button(cx: &mut ViewContext<Self>) -> impl IntoElement {	996	fn render_plus_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
997	IconButton::new("plus_button", Icon::Plus)	997	IconButton::new("plus_button", IconName::Plus)
998	.on_click(cx.listener(\|this, _event, cx\| {	998	.on_click(cx.listener(\|this, _event, cx\| {
999	this.new_conversation(cx);	999	this.new_conversation(cx);
1000	}))	1000	}))
@@ -1004,12 +1004,12 @@ impl AssistantPanel { · 3 unmodified lines
1004		1004
1005	fn render_zoom_button(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {	1005	fn render_zoom_button(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
1006	let zoomed = self.zoomed;	1006	let zoomed = self.zoomed;
1007	IconButton::new("zoom_button", Icon::Maximize)	1007	IconButton::new("zoom_button", IconName::Maximize)
1008	.on_click(cx.listener(\|this, _event, cx\| {	1008	.on_click(cx.listener(\|this, _event, cx\| {
1009	this.toggle_zoom(&ToggleZoom, cx);	1009	this.toggle_zoom(&ToggleZoom, cx);
1010	}))	1010	}))
1011	.selected(zoomed)	1011	.selected(zoomed)
1012	.selected_icon(Icon::Minimize)	1012	.selected_icon(IconName::Minimize)
1013	.icon_size(IconSize::Small)	1013	.icon_size(IconSize::Small)
1014	.tooltip(move \|cx\| {	1014	.tooltip(move \|cx\| {
1015	Tooltip::for_action(if zoomed { "Zoom Out" } else { "Zoom In" }, &ToggleZoom, cx)	1015	Tooltip::for_action(if zoomed { "Zoom Out" } else { "Zoom In" }, &ToggleZoom, cx)
@@ -1286,8 +1286,8 @@ impl Panel for AssistantPanel { · 270 unmodified lines
1286	}	1286	}
1287	}	1287	}
1288		1288
1289	fn icon(&self, cx: &WindowContext) -> Option<Icon> {	1289	fn icon(&self, cx: &WindowContext) -> Option<IconName> {
1290	Some(Icon::Ai).filter(\|_\| AssistantSettings::get_global(cx).button)	1290	Some(IconName::Ai).filter(\|_\| AssistantSettings::get_global(cx).button)
1291	}	1291	}
1292		1292
1293	fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {	1293	fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
@@ -2349,7 +2349,7 @@ impl ConversationEditor { · 1055 unmodified lines
2349	div()	2349	div()
2350	.id("error")	2350	.id("error")
2351	.tooltip(move \|cx\| Tooltip::text(error.clone(), cx))	2351	.tooltip(move \|cx\| Tooltip::text(error.clone(), cx))
2352	.child(IconElement::new(Icon::XCircle)),	2352	.child(Icon::new(IconName::XCircle)),
2353	)	2353	)
2354	} else {	2354	} else {
2355	None	2355	None
@@ -2645,7 +2645,7 @@ impl Render for InlineAssistant { · 289 unmodified lines
2645	.justify_center()	2645	.justify_center()
2646	.w(measurements.gutter_width)	2646	.w(measurements.gutter_width)
2647	.child(	2647	.child(
2648	IconButton::new("include_conversation", Icon::Ai)	2648	IconButton::new("include_conversation", IconName::Ai)
2649	.on_click(cx.listener(\|this, _, cx\| {	2649	.on_click(cx.listener(\|this, _, cx\| {
2650	this.toggle_include_conversation(&ToggleIncludeConversation, cx)	2650	this.toggle_include_conversation(&ToggleIncludeConversation, cx)
2651	}))	2651	}))
@@ -2660,7 +2660,7 @@ impl Render for InlineAssistant { · 8 unmodified lines
2660	)	2660	)
2661	.children(if SemanticIndex::enabled(cx) {	2661	.children(if SemanticIndex::enabled(cx) {
2662	Some(	2662	Some(
2663	IconButton::new("retrieve_context", Icon::MagnifyingGlass)	2663	IconButton::new("retrieve_context", IconName::MagnifyingGlass)
2664	.on_click(cx.listener(\|this, _, cx\| {	2664	.on_click(cx.listener(\|this, _, cx\| {
2665	this.toggle_retrieve_context(&ToggleRetrieveContext, cx)	2665	this.toggle_retrieve_context(&ToggleRetrieveContext, cx)
2666	}))	2666	}))
@@ -2682,7 +2682,7 @@ impl Render for InlineAssistant { · 15 unmodified lines
2682	div()	2682	div()
2683	.id("error")	2683	.id("error")
2684	.tooltip(move \|cx\| Tooltip::text(error_message.clone(), cx))	2684	.tooltip(move \|cx\| Tooltip::text(error_message.clone(), cx))
2685	.child(IconElement::new(Icon::XCircle).color(Color::Error)),	2685	.child(Icon::new(IconName::XCircle).color(Color::Error)),
2686	)	2686	)
2687	} else {	2687	} else {
2688	None	2688	None
@@ -2957,7 +2957,7 @@ impl InlineAssistant { · 268 unmodified lines
2957	div()	2957	div()
2958	.id("error")	2958	.id("error")
2959	.tooltip(\|cx\| Tooltip::text("Not Authenticated. Please ensure you have a valid 'OPENAI_API_KEY' in your environment variables.", cx))	2959	.tooltip(\|cx\| Tooltip::text("Not Authenticated. Please ensure you have a valid 'OPENAI_API_KEY' in your environment variables.", cx))
2960	.child(IconElement::new(Icon::XCircle))	2960	.child(Icon::new(IconName::XCircle))
2961	.into_any_element()	2961	.into_any_element()
2962	),	2962	),
2963		2963
@@ -2965,7 +2965,7 @@ impl InlineAssistant { · 1 unmodified line
2965	div()	2965	div()
2966	.id("error")	2966	.id("error")
2967	.tooltip(\|cx\| Tooltip::text("Not Indexed", cx))	2967	.tooltip(\|cx\| Tooltip::text("Not Indexed", cx))
2968	.child(IconElement::new(Icon::XCircle))	2968	.child(Icon::new(IconName::XCircle))
2969	.into_any_element()	2969	.into_any_element()
2970	),	2970	),
2971		2971
@@ -2996,7 +2996,7 @@ impl InlineAssistant { · 24 unmodified lines
2996	div()	2996	div()
2997	.id("update")	2997	.id("update")
2998	.tooltip(move \|cx\| Tooltip::text(status_text.clone(), cx))	2998	.tooltip(move \|cx\| Tooltip::text(status_text.clone(), cx))
2999	.child(IconElement::new(Icon::Update).color(Color::Info))	2999	.child(Icon::new(IconName::Update).color(Color::Info))
3000	.into_any_element()	3000	.into_any_element()
3001	)	3001	)
3002	}	3002	}
@@ -3005,7 +3005,7 @@ impl InlineAssistant { · 2 unmodified lines
3005	div()	3005	div()
3006	.id("check")	3006	.id("check")
3007	.tooltip(\|cx\| Tooltip::text("Index up to date", cx))	3007	.tooltip(\|cx\| Tooltip::text("Index up to date", cx))
3008	.child(IconElement::new(Icon::Check).color(Color::Success))	3008	.child(Icon::new(IconName::Check).color(Color::Success))
3009	.into_any_element()	3009	.into_any_element()
3010	),	3010	),
3011	}	3011	}

crates/auto_update/src/update_notification.rs+2−2

@@ -4,7 +4,7 @@ use gpui::{ · 3 unmodified lines
4	};	4	};
5	use menu::Cancel;	5	use menu::Cancel;
6	use util::channel::ReleaseChannel;	6	use util::channel::ReleaseChannel;
7	use workspace::ui::{h_stack, v_stack, Icon, IconElement, Label, StyledExt};	7	use workspace::ui::{h_stack, v_stack, Icon, IconName, Label, StyledExt};
8		8
9	pub struct UpdateNotification {	9	pub struct UpdateNotification {
10	version: SemanticVersion,	10	version: SemanticVersion,
@@ -30,7 +30,7 @@ impl Render for UpdateNotification { · 19 unmodified lines
30	.child(	30	.child(
31	div()	31	div()
32	.id("cancel")	32	.id("cancel")
33	.child(IconElement::new(Icon::Close))	33	.child(Icon::new(IconName::Close))
34	.cursor_pointer()	34	.cursor_pointer()
35	.on_click(cx.listener(\|this, _, cx\| this.dismiss(&menu::Cancel, cx))),	35	.on_click(cx.listener(\|this, _, cx\| this.dismiss(&menu::Cancel, cx))),
36	),	36	),

crates/call/src/call_settings.rs+3−0

     pub mute_on_join: bool,
 }
+/// Configuration of voice calls in Zed.
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
 pub struct CallSettingsContent {
     /// Whether the microphone should be muted when joining a channel or a call.
+    ///
+    /// Default: false
     pub mute_on_join: Option<bool>,
 }

crates/client/src/user.rs+2−2

@@ -3,7 +3,7 @@ use anyhow::{anyhow, Context, Result}; · 2 unmodified lines
3	use collections::{hash_map::Entry, HashMap, HashSet};	3	use collections::{hash_map::Entry, HashMap, HashSet};
4	use feature_flags::FeatureFlagAppExt;	4	use feature_flags::FeatureFlagAppExt;
5	use futures::{channel::mpsc, Future, StreamExt};	5	use futures::{channel::mpsc, Future, StreamExt};
6	use gpui::{AsyncAppContext, EventEmitter, Model, ModelContext, SharedString, Task};	6	use gpui::{AsyncAppContext, EventEmitter, Model, ModelContext, SharedUrl, Task};
7	use postage::{sink::Sink, watch};	7	use postage::{sink::Sink, watch};
8	use rpc::proto::{RequestMessage, UsersResponse};	8	use rpc::proto::{RequestMessage, UsersResponse};
9	use std::sync::{Arc, Weak};	9	use std::sync::{Arc, Weak};
@@ -19,7 +19,7 @@ pub struct ParticipantIndex(pub u32); · 9 unmodified lines
19	pub struct User {	19	pub struct User {
20	pub id: UserId,	20	pub id: UserId,
21	pub github_login: String,	21	pub github_login: String,
22	pub avatar_uri: SharedString,	22	pub avatar_uri: SharedUrl,
23	}	23	}
24		24
25	#[derive(Clone, Debug, PartialEq, Eq)]	25	#[derive(Clone, Debug, PartialEq, Eq)]

crates/collab_ui/Cargo.toml+3−0

 doctest = false
 [features]
+default = []
+stories = ["dep:story"]
 test-support = [
     "call/test-support",
     "client/test-support",
 recent_projects = { path = "../recent_projects" }
 rpc = { path = "../rpc" }
 settings = { path = "../settings" }
+story = { path = "../story", optional = true }
 feature_flags = { path = "../feature_flags"}
 theme = { path = "../theme" }
 theme_selector = { path = "../theme_selector" }

crates/collab_ui/src/chat_panel.rs+7−7

@@ -20,7 +20,7 @@ use serde::{Deserialize, Serialize}; · 19 unmodified lines
20	use settings::{Settings, SettingsStore};	20	use settings::{Settings, SettingsStore};
21	use std::sync::Arc;	21	use std::sync::Arc;
22	use time::{OffsetDateTime, UtcOffset};	22	use time::{OffsetDateTime, UtcOffset};
23	use ui::{prelude::*, Avatar, Button, Icon, IconButton, Label, TabBar, Tooltip};	23	use ui::{prelude::*, Avatar, Button, IconButton, IconName, Label, TabBar, Tooltip};
24	use util::{ResultExt, TryFutureExt};	24	use util::{ResultExt, TryFutureExt};
25	use workspace::{	25	use workspace::{
26	dock::{DockPosition, Panel, PanelEvent},	26	dock::{DockPosition, Panel, PanelEvent},
@@ -281,12 +281,12 @@ impl ChatPanel { · 254 unmodified lines
281	)),	281	)),
282	)	282	)
283	.end_child(	283	.end_child(
284	IconButton::new("notes", Icon::File)	284	IconButton::new("notes", IconName::File)
285	.on_click(cx.listener(Self::open_notes))	285	.on_click(cx.listener(Self::open_notes))
286	.tooltip(\|cx\| Tooltip::text("Open notes", cx)),	286	.tooltip(\|cx\| Tooltip::text("Open notes", cx)),
287	)	287	)
288	.end_child(	288	.end_child(
289	IconButton::new("call", Icon::AudioOn)	289	IconButton::new("call", IconName::AudioOn)
290	.on_click(cx.listener(Self::join_call))	290	.on_click(cx.listener(Self::join_call))
291	.tooltip(\|cx\| Tooltip::text("Join call", cx)),	291	.tooltip(\|cx\| Tooltip::text("Join call", cx)),
292	),	292	),
@@ -395,7 +395,7 @@ impl ChatPanel { · 102 unmodified lines
395	.w_8()	395	.w_8()
396	.visible_on_hover("")	396	.visible_on_hover("")
397	.children(message_id_to_remove.map(\|message_id\| {	397	.children(message_id_to_remove.map(\|message_id\| {
398	IconButton::new(("remove", message_id), Icon::XCircle).on_click(	398	IconButton::new(("remove", message_id), IconName::XCircle).on_click(
399	cx.listener(move \|this, _, cx\| {	399	cx.listener(move \|this, _, cx\| {
400	this.remove_message(message_id, cx);	400	this.remove_message(message_id, cx);
401	}),	401	}),
@@ -429,7 +429,7 @@ impl ChatPanel { · 27 unmodified lines
429	Button::new("sign-in", "Sign in")	429	Button::new("sign-in", "Sign in")
430	.style(ButtonStyle::Filled)	430	.style(ButtonStyle::Filled)
431	.icon_color(Color::Muted)	431	.icon_color(Color::Muted)
432	.icon(Icon::Github)	432	.icon(IconName::Github)
433	.icon_position(IconPosition::Start)	433	.icon_position(IconPosition::Start)
434	.full_width()	434	.full_width()
435	.on_click(cx.listener(move \|this, _, cx\| {	435	.on_click(cx.listener(move \|this, _, cx\| {
@@ -622,12 +622,12 @@ impl Panel for ChatPanel { · 186 unmodified lines
622	"ChatPanel"	622	"ChatPanel"
623	}	623	}
624		624
625	fn icon(&self, cx: &WindowContext) -> Option<ui::Icon> {	625	fn icon(&self, cx: &WindowContext) -> Option<ui::IconName> {
626	if !is_channels_feature_enabled(cx) {	626	if !is_channels_feature_enabled(cx) {
627	return None;	627	return None;
628	}	628	}
629		629
630	Some(ui::Icon::MessageBubbles).filter(\|_\| ChatPanelSettings::get_global(cx).button)	630	Some(ui::IconName::MessageBubbles).filter(\|_\| ChatPanelSettings::get_global(cx).button)
631	}	631	}
632		632
633	fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {	633	fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {

crates/collab_ui/src/collab_panel.rs+33−29

 use std::{mem, sync::Arc};
 use theme::{ActiveTheme, ThemeSettings};
 use ui::{
-    prelude::*, Avatar, Button, Color, ContextMenu, Icon, IconButton, IconElement, IconSize, Label,
+    prelude::*, Avatar, Button, Color, ContextMenu, Icon, IconButton, IconName, IconSize, Label,
     ListHeader, ListItem, Tooltip,
 };
 use util::{maybe, ResultExt, TryFutureExt};
             .end_slot(if is_pending {
                 Label::new("Calling").color(Color::Muted).into_any_element()
             } else if is_current_user {
-                IconButton::new("leave-call", Icon::Exit)
+                IconButton::new("leave-call", IconName::Exit)
                     .style(ButtonStyle::Subtle)
                     .on_click(move |_, cx| Self::leave_call(cx))
                     .tooltip(|cx| Tooltip::text("Leave Call", cx))
                 h_stack()
                     .gap_1()
                     .child(render_tree_branch(is_last, false, cx))
-                    .child(IconButton::new(0, Icon::Folder)),
+                    .child(IconButton::new(0, IconName::Folder)),
             )
             .child(Label::new(project_name.clone()))
             .tooltip(move |cx| Tooltip::text(format!("Open {}", project_name), cx))
                 h_stack()
                     .gap_1()
                     .child(render_tree_branch(is_last, false, cx))
-                    .child(IconButton::new(0, Icon::Screen)),
+                    .child(IconButton::new(0, IconName::Screen)),
             )
             .child(Label::new("Screen"))
             .when_some(peer_id, |this, _| {
                 h_stack()
                     .gap_1()
                     .child(render_tree_branch(false, true, cx))
-                    .child(IconButton::new(0, Icon::File)),
+                    .child(IconButton::new(0, IconName::File)),
             )
             .child(div().h_7().w_full().child(Label::new("notes")))
             .tooltip(move |cx| Tooltip::text("Open Channel Notes", cx))
                 h_stack()
                     .gap_1()
                     .child(render_tree_branch(false, false, cx))
-                    .child(IconButton::new(0, Icon::MessageBubbles)),
+                    .child(IconButton::new(0, IconName::MessageBubbles)),
             )
             .child(Label::new("chat"))
             .tooltip(move |cx| Tooltip::text("Open Chat", cx))
                     .child(
                         Button::new("sign_in", "Sign in")
                             .icon_color(Color::Muted)
-                            .icon(Icon::Github)
+                            .icon(IconName::Github)
                             .icon_position(IconPosition::Start)
                             .style(ButtonStyle::Filled)
                             .full_width()
         let button = match section {
             Section::ActiveCall => channel_link.map(|channel_link| {
                 let channel_link_copy = channel_link.clone();
-                IconButton::new("channel-link", Icon::Copy)
+                IconButton::new("channel-link", IconName::Copy)
                     .icon_size(IconSize::Small)
                     .size(ButtonSize::None)
                     .visible_on_hover("section-header")
                     .into_any_element()
             }),
             Section::Contacts => Some(
-                IconButton::new("add-contact", Icon::Plus)
+                IconButton::new("add-contact", IconName::Plus)
                     .on_click(cx.listener(|this, _, cx| this.toggle_contact_finder(cx)))
                     .tooltip(|cx| Tooltip::text("Search for new contact", cx))
                     .into_any_element(),
             ),
             Section::Channels => Some(
-                IconButton::new("add-channel", Icon::Plus)
+                IconButton::new("add-channel", IconName::Plus)
                     .on_click(cx.listener(|this, _, cx| this.new_root_channel(cx)))
                     .tooltip(|cx| Tooltip::text("Create a channel", cx))
                     .into_any_element(),
                         })
                         .when(!calling, |el| {
                             el.child(
-                                IconButton::new("remove_contact", Icon::Close)
+                                IconButton::new("remove_contact", IconName::Close)
                                     .icon_color(Color::Muted)
                                     .visible_on_hover("")
                                     .tooltip(|cx| Tooltip::text("Remove Contact", cx))
         let controls = if is_incoming {
             vec![
-                IconButton::new("decline-contact", Icon::Close)
+                IconButton::new("decline-contact", IconName::Close)
                     .on_click(cx.listener(move |this, _, cx| {
                         this.respond_to_contact_request(user_id, false, cx);
                     }))
                     .icon_color(color)
                     .tooltip(|cx| Tooltip::text("Decline invite", cx)),
-                IconButton::new("accept-contact", Icon::Check)
+                IconButton::new("accept-contact", IconName::Check)
                     .on_click(cx.listener(move |this, _, cx| {
                         this.respond_to_contact_request(user_id, true, cx);
                     }))
             ]
         } else {
             let github_login = github_login.clone();
-            vec![IconButton::new("remove_contact", Icon::Close)
+            vec![IconButton::new("remove_contact", IconName::Close)
                 .on_click(cx.listener(move |this, _, cx| {
                     this.remove_contact(user_id, &github_login, cx);
                 }))
         };
         let controls = [
-            IconButton::new("reject-invite", Icon::Close)
+            IconButton::new("reject-invite", IconName::Close)
                 .on_click(cx.listener(move |this, _, cx| {
                     this.respond_to_channel_invite(channel_id, false, cx);
                 }))
                 .icon_color(color)
                 .tooltip(|cx| Tooltip::text("Decline invite", cx)),
-            IconButton::new("accept-invite", Icon::Check)
+            IconButton::new("accept-invite", IconName::Check)
                 .on_click(cx.listener(move |this, _, cx| {
                     this.respond_to_channel_invite(channel_id, true, cx);
                 }))
                     .child(h_stack().children(controls)),
             )
             .start_slot(
-                IconElement::new(Icon::Hash)
+                Icon::new(IconName::Hash)
                     .size(IconSize::Small)
                     .color(Color::Muted),
             )
         cx: &mut ViewContext<Self>,
     ) -> ListItem {
         ListItem::new("contact-placeholder")
-            .child(IconElement::new(Icon::Plus))
+            .child(Icon::new(IconName::Plus))
             .child(Label::new("Add a Contact"))
             .selected(is_selected)
             .on_click(cx.listener(|this, _, cx| this.toggle_contact_finder(cx)))
         };
         let messages_button = |cx: &mut ViewContext<Self>| {
-            IconButton::new("channel_chat", Icon::MessageBubbles)
+            IconButton::new("channel_chat", IconName::MessageBubbles)
                 .icon_size(IconSize::Small)
                 .icon_color(if has_messages_notification {
                     Color::Default
         };
         let notes_button = |cx: &mut ViewContext<Self>| {
-            IconButton::new("channel_notes", Icon::File)
+            IconButton::new("channel_notes", IconName::File)
                 .icon_size(IconSize::Small)
                 .icon_color(if has_notes_notification {
                     Color::Default
                         },
                     ))
                     .start_slot(
-                        IconElement::new(if is_public { Icon::Public } else { Icon::Hash })
+                        Icon::new(if is_public {
-                            .size(IconSize::Small)
+                            IconName::Public
-                            .color(Color::Muted),
+                        } else {
+                            IconName::Hash
+                        })
+                        .size(IconSize::Small)
+                        .color(Color::Muted),
                     )
                     .child(
                         h_stack()
             .indent_level(depth + 1)
             .indent_step_size(px(20.))
             .start_slot(
-                IconElement::new(Icon::Hash)
+                Icon::new(IconName::Hash)
                     .size(IconSize::Small)
                     .color(Color::Muted),
             );
         cx.notify();
     }
-    fn icon(&self, cx: &gpui::WindowContext) -> Option<ui::Icon> {
+    fn icon(&self, cx: &gpui::WindowContext) -> Option<ui::IconName> {
         CollaborationPanelSettings::get_global(cx)
             .button
-            .then(|| ui::Icon::Collab)
+            .then(|| ui::IconName::Collab)
     }
     fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
             .p_1()
             .gap_1()
             .child(
-                IconElement::new(
+                Icon::new(
                     if self.channel.visibility == proto::ChannelVisibility::Public {
-                        Icon::Public
+                        IconName::Public
                     } else {
-                        Icon::Hash
+                        IconName::Hash
                     },
                 )
                 .size(IconSize::Small)

crates/collab_ui/src/collab_panel/channel_modal.rs+2−2

@@ -168,7 +168,7 @@ impl Render for ChannelModal { · 167 unmodified lines
168	.w_px()	168	.w_px()
169	.flex_1()	169	.flex_1()
170	.gap_1()	170	.gap_1()
171	.child(IconElement::new(Icon::Hash).size(IconSize::Medium))	171	.child(Icon::new(IconName::Hash).size(IconSize::Medium))
172	.child(Label::new(channel_name)),	172	.child(Label::new(channel_name)),
173	)	173	)
174	.child(	174	.child(
@@ -406,7 +406,7 @@ impl PickerDelegate for ChannelModalDelegate { · 231 unmodified lines
406	Some(ChannelRole::Guest) => Some(Label::new("Guest")),	406	Some(ChannelRole::Guest) => Some(Label::new("Guest")),
407	_ => None,	407	_ => None,
408	})	408	})
409	.child(IconButton::new("ellipsis", Icon::Ellipsis))	409	.child(IconButton::new("ellipsis", IconName::Ellipsis))
410	.children(	410	.children(
411	if let (Some((menu, _)), true) = (&self.context_menu, selected) {	411	if let (Some((menu, _)), true) = (&self.context_menu, selected) {
412	Some(	412	Some(

crates/collab_ui/src/collab_panel/contact_finder.rs+1−3

                 .selected(selected)
                 .start_slot(Avatar::new(user.avatar_uri.clone()))
                 .child(Label::new(user.github_login.clone()))
-                .end_slot::<IconElement>(
+                .end_slot::<Icon>(icon_path.map(|icon_path| Icon::from_path(icon_path))),
-                    icon_path.map(|icon_path| IconElement::from_path(icon_path)),
-                ),
         )
     }
 }

crates/collab_ui/src/collab_titlebar_item.rs+10−10

@@ -15,7 +15,7 @@ use std::sync::Arc; · 14 unmodified lines
15	use theme::{ActiveTheme, PlayerColors};	15	use theme::{ActiveTheme, PlayerColors};
16	use ui::{	16	use ui::{
17	h_stack, popover_menu, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon,	17	h_stack, popover_menu, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon,
18	IconButton, IconElement, TintColor, Tooltip,	18	IconButton, IconName, TintColor, Tooltip,
19	};	19	};
20	use util::ResultExt;	20	use util::ResultExt;
21	use vcs_menu::{build_branch_list, BranchList, OpenRecent as ToggleVcsMenu};	21	use vcs_menu::{build_branch_list, BranchList, OpenRecent as ToggleVcsMenu};
@@ -213,7 +213,7 @@ impl Render for CollabTitlebarItem { · 191 unmodified lines
213	.child(	213	.child(
214	div()	214	div()
215	.child(	215	.child(
216	IconButton::new("leave-call", ui::Icon::Exit)	216	IconButton::new("leave-call", ui::IconName::Exit)
217	.style(ButtonStyle::Subtle)	217	.style(ButtonStyle::Subtle)
218	.tooltip(\|cx\| Tooltip::text("Leave call", cx))	218	.tooltip(\|cx\| Tooltip::text("Leave call", cx))
219	.icon_size(IconSize::Small)	219	.icon_size(IconSize::Small)
@@ -230,9 +230,9 @@ impl Render for CollabTitlebarItem { · 10 unmodified lines
230	IconButton::new(	230	IconButton::new(
231	"mute-microphone",	231	"mute-microphone",
232	if is_muted {	232	if is_muted {
233	ui::Icon::MicMute	233	ui::IconName::MicMute
234	} else {	234	} else {
235	ui::Icon::Mic	235	ui::IconName::Mic
236	},	236	},
237	)	237	)
238	.tooltip(move \|cx\| {	238	.tooltip(move \|cx\| {
@@ -256,9 +256,9 @@ impl Render for CollabTitlebarItem { · 17 unmodified lines
256	IconButton::new(	256	IconButton::new(
257	"mute-sound",	257	"mute-sound",
258	if is_deafened {	258	if is_deafened {
259	ui::Icon::AudioOff	259	ui::IconName::AudioOff
260	} else {	260	} else {
261	ui::Icon::AudioOn	261	ui::IconName::AudioOn
262	},	262	},
263	)	263	)
264	.style(ButtonStyle::Subtle)	264	.style(ButtonStyle::Subtle)
@@ -281,7 +281,7 @@ impl Render for CollabTitlebarItem { · 16 unmodified lines
281	)	281	)
282	.when(!read_only, \|this\| {	282	.when(!read_only, \|this\| {
283	this.child(	283	this.child(
284	IconButton::new("screen-share", ui::Icon::Screen)	284	IconButton::new("screen-share", ui::IconName::Screen)
285	.style(ButtonStyle::Subtle)	285	.style(ButtonStyle::Subtle)
286	.icon_size(IconSize::Small)	286	.icon_size(IconSize::Small)
287	.selected(is_screen_sharing)	287	.selected(is_screen_sharing)
@@ -573,7 +573,7 @@ impl CollabTitlebarItem { · 285 unmodified lines
573	\| client::Status::ReconnectionError { .. } => Some(	573	\| client::Status::ReconnectionError { .. } => Some(
574	div()	574	div()
575	.id("disconnected")	575	.id("disconnected")
576	.child(IconElement::new(Icon::Disconnected).size(IconSize::Small))	576	.child(Icon::new(IconName::Disconnected).size(IconSize::Small))
577	.tooltip(\|cx\| Tooltip::text("Disconnected", cx))	577	.tooltip(\|cx\| Tooltip::text("Disconnected", cx))
578	.into_any_element(),	578	.into_any_element(),
579	),	579	),
@@ -643,7 +643,7 @@ impl CollabTitlebarItem { · 63 unmodified lines
643	h_stack()	643	h_stack()
644	.gap_0p5()	644	.gap_0p5()
645	.child(Avatar::new(user.avatar_uri.clone()))	645	.child(Avatar::new(user.avatar_uri.clone()))
646	.child(IconElement::new(Icon::ChevronDown).color(Color::Muted)),	646	.child(Icon::new(IconName::ChevronDown).color(Color::Muted)),
647	)	647	)
648	.style(ButtonStyle::Subtle)	648	.style(ButtonStyle::Subtle)
649	.tooltip(move \|cx\| Tooltip::text("Toggle User Menu", cx)),	649	.tooltip(move \|cx\| Tooltip::text("Toggle User Menu", cx)),
@@ -665,7 +665,7 @@ impl CollabTitlebarItem { · 15 unmodified lines
665	.child(	665	.child(
666	h_stack()	666	h_stack()
667	.gap_0p5()	667	.gap_0p5()
668	.child(IconElement::new(Icon::ChevronDown).color(Color::Muted)),	668	.child(Icon::new(IconName::ChevronDown).color(Color::Muted)),
669	)	669	)
670	.style(ButtonStyle::Subtle)	670	.style(ButtonStyle::Subtle)
671	.tooltip(move \|cx\| Tooltip::text("Toggle User Menu", cx)),	671	.tooltip(move \|cx\| Tooltip::text("Toggle User Menu", cx)),

crates/collab_ui/src/notification_panel.rs+6−6

@@ -19,7 +19,7 @@ use serde::{Deserialize, Serialize}; · 18 unmodified lines
19	use settings::{Settings, SettingsStore};	19	use settings::{Settings, SettingsStore};
20	use std::{sync::Arc, time::Duration};	20	use std::{sync::Arc, time::Duration};
21	use time::{OffsetDateTime, UtcOffset};	21	use time::{OffsetDateTime, UtcOffset};
22	use ui::{h_stack, prelude::*, v_stack, Avatar, Button, Icon, IconButton, IconElement, Label};	22	use ui::{h_stack, prelude::*, v_stack, Avatar, Button, Icon, IconButton, IconName, Label};
23	use util::{ResultExt, TryFutureExt};	23	use util::{ResultExt, TryFutureExt};
24	use workspace::{	24	use workspace::{
25	dock::{DockPosition, Panel, PanelEvent},	25	dock::{DockPosition, Panel, PanelEvent},
@@ -553,7 +553,7 @@ impl Render for NotificationPanel { · 527 unmodified lines
553	.border_b_1()	553	.border_b_1()
554	.border_color(cx.theme().colors().border)	554	.border_color(cx.theme().colors().border)
555	.child(Label::new("Notifications"))	555	.child(Label::new("Notifications"))
556	.child(IconElement::new(Icon::Envelope)),	556	.child(Icon::new(IconName::Envelope)),
557	)	557	)
558	.map(\|this\| {	558	.map(\|this\| {
559	if self.client.user_id().is_none() {	559	if self.client.user_id().is_none() {
@@ -564,7 +564,7 @@ impl Render for NotificationPanel { · 4 unmodified lines
564	.child(	564	.child(
565	Button::new("sign_in_prompt_button", "Sign in")	565	Button::new("sign_in_prompt_button", "Sign in")
566	.icon_color(Color::Muted)	566	.icon_color(Color::Muted)
567	.icon(Icon::Github)	567	.icon(IconName::Github)
568	.icon_position(IconPosition::Start)	568	.icon_position(IconPosition::Start)
569	.style(ButtonStyle::Filled)	569	.style(ButtonStyle::Filled)
570	.full_width()	570	.full_width()
@@ -655,10 +655,10 @@ impl Panel for NotificationPanel { · 84 unmodified lines
655	}	655	}
656	}	656	}
657		657
658	fn icon(&self, cx: &gpui::WindowContext) -> Option<Icon> {	658	fn icon(&self, cx: &gpui::WindowContext) -> Option<IconName> {
659	(NotificationPanelSettings::get_global(cx).button	659	(NotificationPanelSettings::get_global(cx).button
660	&& self.notification_store.read(cx).notification_count() > 0)	660	&& self.notification_store.read(cx).notification_count() > 0)
661	.then(\|\| Icon::Bell)	661	.then(\|\| IconName::Bell)
662	}	662	}
663		663
664	fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {	664	fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
@@ -716,7 +716,7 @@ impl Render for NotificationToast { · 51 unmodified lines
716	.children(user.map(\|user\| Avatar::new(user.avatar_uri.clone())))	716	.children(user.map(\|user\| Avatar::new(user.avatar_uri.clone())))
717	.child(Label::new(self.text.clone()))	717	.child(Label::new(self.text.clone()))
718	.child(	718	.child(
719	IconButton::new("close", Icon::Close)	719	IconButton::new("close", IconName::Close)
720	.on_click(cx.listener(\|_, _, cx\| cx.emit(DismissEvent))),	720	.on_click(cx.listener(\|_, _, cx\| cx.emit(DismissEvent))),
721	)	721	)
722	.on_click(cx.listener(\|this, _, cx\| {	722	.on_click(cx.listener(\|this, _, cx\| {

crates/collab_ui/src/notifications.rs+9−2

+mod collab_notification;
+pub mod incoming_call_notification;
+pub mod project_shared_notification;
+#[cfg(feature = "stories")]
+mod stories;
 use gpui::AppContext;
 use std::sync::Arc;
 use workspace::AppState;
-pub mod incoming_call_notification;
+#[cfg(feature = "stories")]
-pub mod project_shared_notification;
+pub use stories::*;
 pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
     incoming_call_notification::init(app_state, cx);

crates/collab_ui/src/notifications/collab_notification.rs+52−0

@@ -0,0 +1,52 @@
	1	use gpui::{img, prelude::*, AnyElement, SharedUrl};
	2	use smallvec::SmallVec;
	3	use ui::prelude::*;
	4
	5	#[derive(IntoElement)]
	6	pub struct CollabNotification {
	7	avatar_uri: SharedUrl,
	8	accept_button: Button,
	9	dismiss_button: Button,
	10	children: SmallVec<[AnyElement; 2]>,
	11	}
	12
	13	impl CollabNotification {
	14	pub fn new(
	15	avatar_uri: impl Into<SharedUrl>,
	16	accept_button: Button,
	17	dismiss_button: Button,
	18	) -> Self {
	19	Self {
	20	avatar_uri: avatar_uri.into(),
	21	accept_button,
	22	dismiss_button,
	23	children: SmallVec::new(),
	24	}
	25	}
	26	}
	27
	28	impl ParentElement for CollabNotification {
	29	fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
	30	&mut self.children
	31	}
	32	}
	33
	34	impl RenderOnce for CollabNotification {
	35	fn render(self, cx: &mut WindowContext) -> impl IntoElement {
	36	h_stack()
	37	.text_ui()
	38	.justify_between()
	39	.size_full()
	40	.overflow_hidden()
	41	.elevation_3(cx)
	42	.p_2()
	43	.gap_2()
	44	.child(img(self.avatar_uri).w_12().h_12().rounded_full())
	45	.child(v_stack().overflow_hidden().children(self.children))
	46	.child(
	47	v_stack()
	48	.child(self.accept_button)
	49	.child(self.dismiss_button),
	50	)
	51	}
	52	}

crates/collab_ui/src/notifications/incoming_call_notification.rs+18−34

 use crate::notification_window_options;
+use crate::notifications::collab_notification::CollabNotification;
 use call::{ActiveCall, IncomingCall};
 use futures::StreamExt;
-use gpui::{
+use gpui::{prelude::*, AppContext, WindowHandle};
-    img, px, AppContext, ParentElement, Render, RenderOnce, Styled, ViewContext,
-    VisualContext as _, WindowHandle,
-};
 use settings::Settings;
 use std::sync::{Arc, Weak};
 use theme::ThemeSettings;
-use ui::prelude::*;
+use ui::{prelude::*, Button, Label};
-use ui::{h_stack, v_stack, Button, Label};
 use util::ResultExt;
 use workspace::AppState;
             if let Some(incoming_call) = incoming_call {
                 let unique_screens = cx.update(|cx| cx.displays()).unwrap();
                 let window_size = gpui::Size {
-                    width: px(380.),
+                    width: px(400.),
-                    height: px(64.),
+                    height: px(72.),
                 };
                 for screen in unique_screens {
         cx.set_rem_size(ui_font_size);
-        h_stack()
+        div().size_full().font(ui_font).child(
-            .font(ui_font)
+            CollabNotification::new(
-            .text_ui()
+                self.state.call.calling_user.avatar_uri.clone(),
-            .justify_between()
+                Button::new("accept", "Accept").on_click({
-            .size_full()
+                    let state = self.state.clone();
-            .overflow_hidden()
+                    move |_, cx| state.respond(true, cx)
-            .elevation_3(cx)
+                }),
-            .p_2()
+                Button::new("decline", "Decline").on_click({
-            .gap_2()
+                    let state = self.state.clone();
-            .child(
+                    move |_, cx| state.respond(false, cx)
-                img(self.state.call.calling_user.avatar_uri.clone())
+                }),
-                    .w_12()
-                    .h_12()
-                    .rounded_full(),
             )
             .child(v_stack().overflow_hidden().child(Label::new(format!(
                 "{} is sharing a project in Zed",
                 self.state.call.calling_user.github_login
-            ))))
+            )))),
-            .child(
+        )
-                v_stack()
-                    .child(Button::new("accept", "Accept").render(cx).on_click({
-                        let state = self.state.clone();
-                        move |_, cx| state.respond(true, cx)
-                    }))
-                    .child(Button::new("decline", "Decline").render(cx).on_click({
-                        let state = self.state.clone();
-                        move |_, cx| state.respond(false, cx)
-                    })),
-            )
     }
 }

crates/collab_ui/src/notifications/project_shared_notification.rs+27−47

 use crate::notification_window_options;
+use crate::notifications::collab_notification::CollabNotification;
 use call::{room, ActiveCall};
 use client::User;
 use collections::HashMap;
-use gpui::{img, px, AppContext, ParentElement, Render, Size, Styled, ViewContext, VisualContext};
+use gpui::{AppContext, Size};
 use settings::Settings;
 use std::sync::{Arc, Weak};
 use theme::ThemeSettings;
-use ui::{h_stack, prelude::*, v_stack, Button, Label};
+use ui::{prelude::*, Button, Label};
 use workspace::AppState;
 pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
         cx.set_rem_size(ui_font_size);
-        h_stack()
+        div().size_full().font(ui_font).child(
-            .font(ui_font)
+            CollabNotification::new(
-            .text_ui()
+                self.owner.avatar_uri.clone(),
-            .justify_between()
+                Button::new("open", "Open").on_click(cx.listener(move |this, _event, cx| {
-            .size_full()
+                    this.join(cx);
-            .overflow_hidden()
+                })),
-            .elevation_3(cx)
+                Button::new("dismiss", "Dismiss").on_click(cx.listener(move |this, _event, cx| {
-            .p_2()
+                    this.dismiss(cx);
-            .gap_2()
+                })),
-            .child(
-                img(self.owner.avatar_uri.clone())
-                    .w_12()
-                    .h_12()
-                    .rounded_full(),
-            )
-            .child(
-                v_stack()
-                    .overflow_hidden()
-                    .child(Label::new(self.owner.github_login.clone()))
-                    .child(Label::new(format!(
-                        "is sharing a project in Zed{}",
-                        if self.worktree_root_names.is_empty() {
-                            ""
-                        } else {
-                            ":"
-                        }
-                    )))
-                    .children(if self.worktree_root_names.is_empty() {
-                        None
-                    } else {
-                        Some(Label::new(self.worktree_root_names.join(", ")))
-                    }),
-            )
-            .child(
-                v_stack()
-                    .child(Button::new("open", "Open").on_click(cx.listener(
-                        move |this, _event, cx| {
-                            this.join(cx);
-                        },
-                    )))
-                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
-                        move |this, _event, cx| {
-                            this.dismiss(cx);
-                        },
-                    ))),
             )
+            .child(Label::new(self.owner.github_login.clone()))
+            .child(Label::new(format!(
+                "is sharing a project in Zed{}",
+                if self.worktree_root_names.is_empty() {
+                    ""
+                } else {
+                    ":"
+                }
+            )))
+            .children(if self.worktree_root_names.is_empty() {
+                None
+            } else {
+                Some(Label::new(self.worktree_root_names.join(", ")))
+            }),
+        )
     }
 }

crates/collab_ui/src/notifications/stories.rs+3−0

@@ -0,0 +1,3 @@
	1	mod collab_notification;
	2
	3	pub use collab_notification::*;

crates/collab_ui/src/notifications/stories/collab_notification.rs+50−0

@@ -0,0 +1,50 @@
	1	use gpui::prelude::*;
	2	use story::{StoryContainer, StoryItem, StorySection};
	3	use ui::prelude::*;
	4
	5	use crate::notifications::collab_notification::CollabNotification;
	6
	7	pub struct CollabNotificationStory;
	8
	9	impl Render for CollabNotificationStory {
	10	fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
	11	let window_container = \|width, height\| div().w(px(width)).h(px(height));
	12
	13	StoryContainer::new(
	14	"CollabNotification Story",
	15	"crates/collab_ui/src/notifications/stories/collab_notification.rs",
	16	)
	17	.child(
	18	StorySection::new().child(StoryItem::new(
	19	"Incoming Call Notification",
	20	window_container(400., 72.).child(
	21	CollabNotification::new(
	22	"https://avatars.githubusercontent.com/u/1486634?v=4",
	23	Button::new("accept", "Accept"),
	24	Button::new("decline", "Decline"),
	25	)
	26	.child(
	27	v_stack()
	28	.overflow_hidden()
	29	.child(Label::new("maxdeviant is sharing a project in Zed")),
	30	),
	31	),
	32	)),
	33	)
	34	.child(
	35	StorySection::new().child(StoryItem::new(
	36	"Project Shared Notification",
	37	window_container(400., 72.).child(
	38	CollabNotification::new(
	39	"https://avatars.githubusercontent.com/u/1714999?v=4",
	40	Button::new("open", "Open"),
	41	Button::new("dismiss", "Dismiss"),
	42	)
	43	.child(Label::new("iamnbutler"))
	44	.child(Label::new("is sharing a project in Zed:"))
	45	.child(Label::new("zed")),
	46	),
	47	)),
	48	)
	49	}
	50	}

crates/copilot_ui/src/copilot_button.rs+7−5

 use workspace::{
     create_and_open_local_file,
     item::ItemHandle,
-    ui::{popover_menu, ButtonCommon, Clickable, ContextMenu, Icon, IconButton, IconSize, Tooltip},
+    ui::{
+        popover_menu, ButtonCommon, Clickable, ContextMenu, IconButton, IconName, IconSize, Tooltip,
+    },
     StatusItemView, Toast, Workspace,
 };
 use zed_actions::OpenBrowser;
             .unwrap_or_else(|| all_language_settings.copilot_enabled(None, None));
         let icon = match status {
-            Status::Error(_) => Icon::CopilotError,
+            Status::Error(_) => IconName::CopilotError,
             Status::Authorized => {
                 if enabled {
-                    Icon::Copilot
+                    IconName::Copilot
                 } else {
-                    Icon::CopilotDisabled
+                    IconName::CopilotDisabled
                 }
             }
-            _ => Icon::CopilotInit,
+            _ => IconName::CopilotInit,
         };
         if let Status::Error(e) = status {

crates/copilot_ui/src/sign_in.rs+2−2

@@ -4,7 +4,7 @@ use gpui::{ · 3 unmodified lines
4	FocusableView, InteractiveElement, IntoElement, Model, ParentElement, Render, Styled,	4	FocusableView, InteractiveElement, IntoElement, Model, ParentElement, Render, Styled,
5	Subscription, ViewContext,	5	Subscription, ViewContext,
6	};	6	};
7	use ui::{prelude::*, Button, Icon, Label};	7	use ui::{prelude::*, Button, IconName, Label};
8	use workspace::ModalView;	8	use workspace::ModalView;
9		9
10	const COPILOT_SIGN_UP_URL: &'static str = "https://github.com/features/copilot";	10	const COPILOT_SIGN_UP_URL: &'static str = "https://github.com/features/copilot";
@@ -175,7 +175,7 @@ impl Render for CopilotCodeVerification { · 164 unmodified lines
175	.w_32()	175	.w_32()
176	.h_16()	176	.h_16()
177	.flex_none()	177	.flex_none()
178	.path(Icon::ZedXCopilot.path())	178	.path(IconName::ZedXCopilot.path())
179	.text_color(cx.theme().colors().icon),	179	.text_color(cx.theme().colors().icon),
180	)	180	)
181	.child(prompt)	181	.child(prompt)

crates/diagnostics/src/diagnostics.rs+5−7

 };
 use theme::ActiveTheme;
 pub use toolbar_controls::ToolbarControls;
-use ui::{h_stack, prelude::*, Icon, IconElement, Label};
+use ui::{h_stack, prelude::*, Icon, IconName, Label};
 use util::TryFutureExt;
 use workspace::{
     item::{BreadcrumbText, Item, ItemEvent, ItemHandle},
                     then.child(
                         h_stack()
                             .gap_1()
-                            .child(IconElement::new(Icon::XCircle).color(Color::Error))
+                            .child(Icon::new(IconName::XCircle).color(Color::Error))
                             .child(Label::new(self.summary.error_count.to_string()).color(
                                 if selected {
                                     Color::Default
                     then.child(
                         h_stack()
                             .gap_1()
-                            .child(
+                            .child(Icon::new(IconName::ExclamationTriangle).color(Color::Warning))
-                                IconElement::new(Icon::ExclamationTriangle).color(Color::Warning),
-                            )
                             .child(Label::new(self.summary.warning_count.to_string()).color(
                                 if selected {
                                     Color::Default
                                 .flex_none()
                                 .map(|icon| {
                                     if diagnostic.severity == DiagnosticSeverity::ERROR {
-                                        icon.path(Icon::XCircle.path())
+                                        icon.path(IconName::XCircle.path())
                                             .text_color(Color::Error.color(cx))
                                     } else {
-                                        icon.path(Icon::ExclamationTriangle.path())
+                                        icon.path(IconName::ExclamationTriangle.path())
                                             .text_color(Color::Warning.color(cx))
                                     }
                                 }),

crates/diagnostics/src/items.rs+7−7

@@ -6,7 +6,7 @@ use gpui::{ · 5 unmodified lines
6	};	6	};
7	use language::Diagnostic;	7	use language::Diagnostic;
8	use lsp::LanguageServerId;	8	use lsp::LanguageServerId;
9	use ui::{h_stack, prelude::*, Button, ButtonLike, Color, Icon, IconElement, Label, Tooltip};	9	use ui::{h_stack, prelude::*, Button, ButtonLike, Color, Icon, IconName, Label, Tooltip};
10	use workspace::{item::ItemHandle, StatusItemView, ToolbarItemEvent, Workspace};	10	use workspace::{item::ItemHandle, StatusItemView, ToolbarItemEvent, Workspace};
11		11
12	use crate::{Deploy, ProjectDiagnosticsEditor};	12	use crate::{Deploy, ProjectDiagnosticsEditor};
@@ -25,7 +25,7 @@ impl Render for DiagnosticIndicator { · 12 unmodified lines
25	let diagnostic_indicator = match (self.summary.error_count, self.summary.warning_count) {	25	let diagnostic_indicator = match (self.summary.error_count, self.summary.warning_count) {
26	(0, 0) => h_stack().map(\|this\| {	26	(0, 0) => h_stack().map(\|this\| {
27	this.child(	27	this.child(
28	IconElement::new(Icon::Check)	28	Icon::new(IconName::Check)
29	.size(IconSize::Small)	29	.size(IconSize::Small)
30	.color(Color::Default),	30	.color(Color::Default),
31	)	31	)
@@ -33,7 +33,7 @@ impl Render for DiagnosticIndicator { · 1 unmodified line
33	(0, warning_count) => h_stack()	33	(0, warning_count) => h_stack()
34	.gap_1()	34	.gap_1()
35	.child(	35	.child(
36	IconElement::new(Icon::ExclamationTriangle)	36	Icon::new(IconName::ExclamationTriangle)
37	.size(IconSize::Small)	37	.size(IconSize::Small)
38	.color(Color::Warning),	38	.color(Color::Warning),
39	)	39	)
@@ -41,7 +41,7 @@ impl Render for DiagnosticIndicator { · 1 unmodified line
41	(error_count, 0) => h_stack()	41	(error_count, 0) => h_stack()
42	.gap_1()	42	.gap_1()
43	.child(	43	.child(
44	IconElement::new(Icon::XCircle)	44	Icon::new(IconName::XCircle)
45	.size(IconSize::Small)	45	.size(IconSize::Small)
46	.color(Color::Error),	46	.color(Color::Error),
47	)	47	)
@@ -49,13 +49,13 @@ impl Render for DiagnosticIndicator { · 1 unmodified line
49	(error_count, warning_count) => h_stack()	49	(error_count, warning_count) => h_stack()
50	.gap_1()	50	.gap_1()
51	.child(	51	.child(
52	IconElement::new(Icon::XCircle)	52	Icon::new(IconName::XCircle)
53	.size(IconSize::Small)	53	.size(IconSize::Small)
54	.color(Color::Error),	54	.color(Color::Error),
55	)	55	)
56	.child(Label::new(error_count.to_string()).size(LabelSize::Small))	56	.child(Label::new(error_count.to_string()).size(LabelSize::Small))
57	.child(	57	.child(
58	IconElement::new(Icon::ExclamationTriangle)	58	Icon::new(IconName::ExclamationTriangle)
59	.size(IconSize::Small)	59	.size(IconSize::Small)
60	.color(Color::Warning),	60	.color(Color::Warning),
61	)	61	)
@@ -66,7 +66,7 @@ impl Render for DiagnosticIndicator { · 4 unmodified lines
66	Some(	66	Some(
67	h_stack()	67	h_stack()
68	.gap_2()	68	.gap_2()
69	.child(IconElement::new(Icon::ArrowCircle).size(IconSize::Small))	69	.child(Icon::new(IconName::ArrowCircle).size(IconSize::Small))
70	.child(	70	.child(
71	Label::new("Checking…")	71	Label::new("Checking…")
72	.size(LabelSize::Small)	72	.size(LabelSize::Small)

crates/diagnostics/src/toolbar_controls.rs+2−2

@@ -1,7 +1,7 @@
1	use crate::ProjectDiagnosticsEditor;	1	use crate::ProjectDiagnosticsEditor;
2	use gpui::{div, EventEmitter, ParentElement, Render, ViewContext, WeakView};	2	use gpui::{div, EventEmitter, ParentElement, Render, ViewContext, WeakView};
3	use ui::prelude::*;	3	use ui::prelude::*;
4	use ui::{Icon, IconButton, Tooltip};	4	use ui::{IconButton, IconName, Tooltip};
5	use workspace::{item::ItemHandle, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView};	5	use workspace::{item::ItemHandle, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView};
6		6
7	pub struct ToolbarControls {	7	pub struct ToolbarControls {
@@ -24,7 +24,7 @@ impl Render for ToolbarControls { · 16 unmodified lines
24	};	24	};
25		25
26	div().child(	26	div().child(
27	IconButton::new("toggle-warnings", Icon::ExclamationTriangle)	27	IconButton::new("toggle-warnings", IconName::ExclamationTriangle)
28	.tooltip(move \|cx\| Tooltip::text(tooltip, cx))	28	.tooltip(move \|cx\| Tooltip::text(tooltip, cx))
29	.on_click(cx.listener(\|this, _, cx\| {	29	.on_click(cx.listener(\|this, _, cx\| {
30	if let Some(editor) = this.editor.as_ref().and_then(\|editor\| editor.upgrade()) {	30	if let Some(editor) = this.editor.as_ref().and_then(\|editor\| editor.upgrade()) {

crates/editor/src/display_map.rs+0−1

@@ -1015,7 +1015,6 @@ pub mod tests { · 1014 unmodified lines
1015	.map(\|i\| i.parse().expect("invalid `OPERATIONS` variable"))	1015	.map(\|i\| i.parse().expect("invalid `OPERATIONS` variable"))
1016	.unwrap_or(10);	1016	.unwrap_or(10);
1017		1017
1018	let _test_platform = &cx.test_platform;
1019	let mut tab_size = rng.gen_range(1..=4);	1018	let mut tab_size = rng.gen_range(1..=4);
1020	let buffer_start_excerpt_header_height = rng.gen_range(1..=5);	1019	let buffer_start_excerpt_header_height = rng.gen_range(1..=5);
1021	let excerpt_header_height = rng.gen_range(1..=5);	1020	let excerpt_header_height = rng.gen_range(1..=5);

crates/editor/src/editor.rs+25−7

 use text::{OffsetUtf16, Rope};
 use theme::{ActiveTheme, PlayerColor, StatusColors, SyntaxTheme, ThemeColors, ThemeSettings};
 use ui::{
-    h_stack, prelude::*, ButtonSize, ButtonStyle, Icon, IconButton, IconSize, ListItem, Popover,
+    h_stack, prelude::*, ButtonSize, ButtonStyle, IconButton, IconName, IconSize, ListItem,
-    Tooltip,
+    Popover, Tooltip,
 };
 use util::{post_inc, RangeExt, ResultExt, TryFutureExt};
 use workspace::{searchable::SearchEvent, ItemNavHistory, Pane, SplitDirection, ViewId, Workspace};
     Column(u32),
 }
-#[derive(Clone, Default)]
+#[derive(Clone)]
 pub struct EditorStyle {
     pub background: Hsla,
     pub local_player: PlayerColor,
     pub suggestions_style: HighlightStyle,
 }
+impl Default for EditorStyle {
+    fn default() -> Self {
+        Self {
+            background: Hsla::default(),
+            local_player: PlayerColor::default(),
+            text: TextStyle::default(),
+            scrollbar_width: Pixels::default(),
+            syntax: Default::default(),
+            // HACK: Status colors don't have a real default.
+            // We should look into removing the status colors from the editor
+            // style and retrieve them directly from the theme.
+            status: StatusColors::dark(),
+            inlays_style: HighlightStyle::default(),
+            suggestions_style: HighlightStyle::default(),
+        }
+    }
+}
 type CompletionId = usize;
 // type GetFieldEditorTheme = dyn Fn(&theme::Theme) -> theme::FieldEditor;
     ) -> Option<IconButton> {
         if self.available_code_actions.is_some() {
             Some(
-                IconButton::new("code_actions_indicator", ui::Icon::Bolt)
+                IconButton::new("code_actions_indicator", ui::IconName::Bolt)
                     .icon_size(IconSize::Small)
                     .icon_color(Color::Muted)
                     .selected(is_active)
                 fold_data
                     .map(|(fold_status, buffer_row, active)| {
                         (active || gutter_hovered || fold_status == FoldStatus::Folded).then(|| {
-                            IconButton::new(ix as usize, ui::Icon::ChevronDown)
+                            IconButton::new(ix as usize, ui::IconName::ChevronDown)
                                 .on_click(cx.listener(move |editor, _e, cx| match fold_status {
                                     FoldStatus::Folded => {
                                         editor.unfold_at(&UnfoldAt { buffer_row }, cx);
                                 .icon_color(ui::Color::Muted)
                                 .icon_size(ui::IconSize::Small)
                                 .selected(fold_status == FoldStatus::Folded)
-                                .selected_icon(ui::Icon::ChevronRight)
+                                .selected_icon(ui::IconName::ChevronRight)
                                 .size(ui::ButtonSize::None)
                         })
                     })
                 ),
             )
             .child(
-                IconButton::new(("copy-block", cx.block_id), Icon::Copy)
+                IconButton::new(("copy-block", cx.block_id), IconName::Copy)
                     .icon_color(Color::Muted)
                     .size(ButtonSize::Compact)
                     .style(ButtonStyle::Transparent)

crates/editor/src/element.rs+55−46

     AnchorCorner, AnyElement, AvailableSpace, BorrowWindow, Bounds, ContentMask, Corners,
     CursorStyle, DispatchPhase, Edges, Element, ElementInputHandler, Hsla, InteractiveBounds,
     InteractiveElement, IntoElement, ModifiersChangedEvent, MouseButton, MouseDownEvent,
-    MouseMoveEvent, MouseUpEvent, ParentElement, Pixels, ScrollWheelEvent, ShapedLine,
+    MouseMoveEvent, MouseUpEvent, ParentElement, Pixels, ScrollDelta, ScrollWheelEvent, ShapedLine,
     SharedString, Size, StackingOrder, StatefulInteractiveElement, Style, Styled, TextRun,
     TextStyle, View, ViewContext, WindowContext,
 };
         }
     }
-    fn scroll(
-        editor: &mut Editor,
-        event: &ScrollWheelEvent,
-        position_map: &PositionMap,
-        bounds: &InteractiveBounds,
-        cx: &mut ViewContext<Editor>,
-    ) {
-        if !bounds.visibly_contains(&event.position, cx) {
-            return;
-        }
-        let line_height = position_map.line_height;
-        let max_glyph_width = position_map.em_width;
-        let (delta, axis) = match event.delta {
-            gpui::ScrollDelta::Pixels(mut pixels) => {
-                //Trackpad
-                let axis = position_map.snapshot.ongoing_scroll.filter(&mut pixels);
-                (pixels, axis)
-            }
-            gpui::ScrollDelta::Lines(lines) => {
-                //Not trackpad
-                let pixels = point(lines.x * max_glyph_width, lines.y * line_height);
-                (pixels, None)
-            }
-        };
-        let scroll_position = position_map.snapshot.scroll_position();
-        let x = f32::from((scroll_position.x * max_glyph_width - delta.x) / max_glyph_width);
-        let y = f32::from((scroll_position.y * line_height - delta.y) / line_height);
-        let scroll_position = point(x, y).clamp(&point(0., 0.), &position_map.scroll_max);
-        editor.scroll(scroll_position, axis, cx);
-        cx.stop_propagation();
-    }
     fn paint_background(
         &self,
         gutter_bounds: Bounds<Pixels>,
         )
     }
-    fn paint_mouse_listeners(
+    fn paint_scroll_wheel_listener(
         &mut self,
-        bounds: Bounds<Pixels>,
+        interactive_bounds: &InteractiveBounds,
-        gutter_bounds: Bounds<Pixels>,
-        text_bounds: Bounds<Pixels>,
         layout: &LayoutState,
         cx: &mut WindowContext,
     ) {
-        let interactive_bounds = InteractiveBounds {
-            bounds: bounds.intersect(&cx.content_mask().bounds),
-            stacking_order: cx.stacking_order().clone(),
-        };
         cx.on_mouse_event({
             let position_map = layout.position_map.clone();
             let editor = self.editor.clone();
             let interactive_bounds = interactive_bounds.clone();
+            let mut delta = ScrollDelta::default();
             move |event: &ScrollWheelEvent, phase, cx| {
                 if phase == DispatchPhase::Bubble
                     && interactive_bounds.visibly_contains(&event.position, cx)
                 {
+                    delta = delta.coalesce(event.delta);
                     editor.update(cx, |editor, cx| {
-                        Self::scroll(editor, event, &position_map, &interactive_bounds, cx)
+                        let position = event.position;
+                        let position_map: &PositionMap = &position_map;
+                        let bounds = &interactive_bounds;
+                        if !bounds.visibly_contains(&position, cx) {
+                            return;
+                        }
+                        let line_height = position_map.line_height;
+                        let max_glyph_width = position_map.em_width;
+                        let (delta, axis) = match delta {
+                            gpui::ScrollDelta::Pixels(mut pixels) => {
+                                //Trackpad
+                                let axis = position_map.snapshot.ongoing_scroll.filter(&mut pixels);
+                                (pixels, axis)
+                            }
+                            gpui::ScrollDelta::Lines(lines) => {
+                                //Not trackpad
+                                let pixels =
+                                    point(lines.x * max_glyph_width, lines.y * line_height);
+                                (pixels, None)
+                            }
+                        };
+                        let scroll_position = position_map.snapshot.scroll_position();
+                        let x = f32::from(
+                            (scroll_position.x * max_glyph_width - delta.x) / max_glyph_width,
+                        );
+                        let y =
+                            f32::from((scroll_position.y * line_height - delta.y) / line_height);
+                        let scroll_position =
+                            point(x, y).clamp(&point(0., 0.), &position_map.scroll_max);
+                        editor.scroll(scroll_position, axis, cx);
+                        cx.stop_propagation();
                     });
                 }
             }
         });
+    }
+    fn paint_mouse_listeners(
+        &mut self,
+        bounds: Bounds<Pixels>,
+        gutter_bounds: Bounds<Pixels>,
+        text_bounds: Bounds<Pixels>,
+        layout: &LayoutState,
+        cx: &mut WindowContext,
+    ) {
+        let interactive_bounds = InteractiveBounds {
+            bounds: bounds.intersect(&cx.content_mask().bounds),
+            stacking_order: cx.stacking_order().clone(),
+        };
+        self.paint_scroll_wheel_listener(&interactive_bounds, layout, cx);
         cx.on_mouse_event({
             let position_map = layout.position_map.clone();

crates/editor/src/hover_popover.rs+13−11

 use project::{HoverBlock, HoverBlockKind, InlayHintLabelPart, Project};
 use settings::Settings;
 use std::{ops::Range, sync::Arc, time::Duration};
-use ui::{StyledExt, Tooltip};
+use ui::{prelude::*, Tooltip};
 use util::TryFutureExt;
 use workspace::Workspace;
             None => self.local_diagnostic.diagnostic.message.clone(),
         };
+        let status_colors = cx.theme().status();
         struct DiagnosticColors {
             pub background: Hsla,
             pub border: Hsla,
         let diagnostic_colors = match self.local_diagnostic.diagnostic.severity {
             DiagnosticSeverity::ERROR => DiagnosticColors {
-                background: style.status.error_background,
+                background: status_colors.error_background,
-                border: style.status.error_border,
+                border: status_colors.error_border,
             },
             DiagnosticSeverity::WARNING => DiagnosticColors {
-                background: style.status.warning_background,
+                background: status_colors.warning_background,
-                border: style.status.warning_border,
+                border: status_colors.warning_border,
             },
             DiagnosticSeverity::INFORMATION => DiagnosticColors {
-                background: style.status.info_background,
+                background: status_colors.info_background,
-                border: style.status.info_border,
+                border: status_colors.info_border,
             },
             DiagnosticSeverity::HINT => DiagnosticColors {
-                background: style.status.hint_background,
+                background: status_colors.hint_background,
-                border: style.status.hint_border,
+                border: status_colors.hint_border,
             },
             _ => DiagnosticColors {
-                background: style.status.ignored_background,
+                background: status_colors.ignored_background,
-                border: style.status.ignored_border,
+                border: status_colors.ignored_border,
             },
         };

crates/editor/src/scroll.rs+6−4

     ) {
         hide_hover(self, cx);
         let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
-        let top_row = scroll_anchor
+        let snapshot = &self.buffer().read(cx).snapshot(cx);
-            .anchor
+        if !scroll_anchor.anchor.is_valid(snapshot) {
-            .to_point(&self.buffer().read(cx).snapshot(cx))
+            log::warn!("Invalid scroll anchor: {:?}", scroll_anchor);
-            .row;
+            return;
+        }
+        let top_row = scroll_anchor.anchor.to_point(snapshot).row;
         self.scroll_manager
             .set_anchor(scroll_anchor, top_row, false, false, workspace_id, cx);
     }

crates/editor/src/test.rs+2−4

 #[allow(dead_code)]
 #[cfg(any(test, feature = "test-support"))]
 pub(crate) fn build_editor(buffer: Model<MultiBuffer>, cx: &mut ViewContext<Editor>) -> Editor {
-    // todo!()
+    Editor::new(EditorMode::Full, buffer, None, cx)
-    Editor::new(EditorMode::Full, buffer, None, /*None,*/ cx)
 }
 pub(crate) fn build_editor_with_project(
     buffer: Model<MultiBuffer>,
     cx: &mut ViewContext<Editor>,
 ) -> Editor {
-    // todo!()
+    Editor::new(EditorMode::Full, buffer, Some(project), cx)
-    Editor::new(EditorMode::Full, buffer, Some(project), /*None,*/ cx)
 }

crates/feedback/src/deploy_feedback_button.rs+2−2

@@ -1,5 +1,5 @@
1	use gpui::{Render, ViewContext, WeakView};	1	use gpui::{Render, ViewContext, WeakView};
2	use ui::{prelude::*, ButtonCommon, Icon, IconButton, Tooltip};	2	use ui::{prelude::*, ButtonCommon, IconButton, IconName, Tooltip};
3	use workspace::{item::ItemHandle, StatusItemView, Workspace};	3	use workspace::{item::ItemHandle, StatusItemView, Workspace};
4		4
5	use crate::{feedback_modal::FeedbackModal, GiveFeedback};	5	use crate::{feedback_modal::FeedbackModal, GiveFeedback};
@@ -27,7 +27,7 @@ impl Render for DeployFeedbackButton { · 21 unmodified lines
27	})	27	})
28	})	28	})
29	.is_some();	29	.is_some();
30	IconButton::new("give-feedback", Icon::Envelope)	30	IconButton::new("give-feedback", IconName::Envelope)
31	.style(ui::ButtonStyle::Subtle)	31	.style(ui::ButtonStyle::Subtle)
32	.icon_size(IconSize::Small)	32	.icon_size(IconSize::Small)
33	.selected(is_open)	33	.selected(is_open)

crates/feedback/src/feedback_modal.rs+1−1

@@ -488,7 +488,7 @@ impl Render for FeedbackModal { · 487 unmodified lines
488	.child(	488	.child(
489	Button::new("community_repository", "Community Repository")	489	Button::new("community_repository", "Community Repository")
490	.style(ButtonStyle::Transparent)	490	.style(ButtonStyle::Transparent)
491	.icon(Icon::ExternalLink)	491	.icon(IconName::ExternalLink)
492	.icon_position(IconPosition::End)	492	.icon_position(IconPosition::End)
493	.icon_size(IconSize::Small)	493	.icon_size(IconSize::Small)
494	.on_click(open_community_repo),	494	.on_click(open_community_repo),

crates/gpui/docs/key_dispatch.md+2−2

@@ -50,7 +50,7 @@ impl Render for Menu { · 49 unmodified lines
50	.on_action(\|this, move: &MoveDown, cx\| {	50	.on_action(\|this, move: &MoveDown, cx\| {
51	// ...	51	// ...
52	})	52	})
53	.children(todo!())	53	.children(unimplemented!())
54	}	54	}
55	}	55	}
56	```	56	```
@@ -68,7 +68,7 @@ impl Render for Menu { · 11 unmodified lines
68	.on_action(\|this, move: &MoveDown, cx\| {	68	.on_action(\|this, move: &MoveDown, cx\| {
69	// ...	69	// ...
70	})	70	})
71	.children(todo!())	71	.children(unimplemented!())
72	}	72	}
73	}	73	}
74	```	74	```

crates/gpui/src/action.rs+17−6

     pub(crate) fn load_actions(&mut self) {
         for builder in __GPUI_ACTIONS {
             let action = builder();
-            //todo(remove)
+            self.insert_action(action);
-            let name: SharedString = action.name.into();
-            self.builders_by_name.insert(name.clone(), action.build);
-            self.names_by_type_id.insert(action.type_id, name.clone());
-            self.all_names.push(name);
         }
     }
+    #[cfg(test)]
+    pub(crate) fn load_action<A: Action>(&mut self) {
+        self.insert_action(ActionData {
+            name: A::debug_name(),
+            type_id: TypeId::of::<A>(),
+            build: A::build,
+        });
+    }
+    fn insert_action(&mut self, action: ActionData) {
+        let name: SharedString = action.name.into();
+        self.builders_by_name.insert(name.clone(), action.build);
+        self.names_by_type_id.insert(action.type_id, name.clone());
+        self.all_names.push(name);
+    }
     /// Construct an action based on its name and optional JSON parameters sourced from the keymap.
     pub fn build_action_type(&self, type_id: &TypeId) -> Result<Box<dyn Action>> {
         let name = self
                 )
             }
-            // todo!() why is this needed in addition to name?
             fn debug_name() -> &'static str
             where
                 Self: ::std::marker::Sized

crates/gpui/src/app.rs+28−13

 /// Temporary(?) wrapper around [`RefCell<AppContext>`] to help us debug any double borrows.
 /// Strongly consider removing after stabilization.
+#[doc(hidden)]
 pub struct AppCell {
     app: RefCell<AppContext>,
 }
 impl AppCell {
+    #[doc(hidden)]
     #[track_caller]
     pub fn borrow(&self) -> AppRef {
         if option_env!("TRACK_THREAD_BORROWS").is_some() {
         AppRef(self.app.borrow())
     }
+    #[doc(hidden)]
     #[track_caller]
     pub fn borrow_mut(&self) -> AppRefMut {
         if option_env!("TRACK_THREAD_BORROWS").is_some() {
     }
 }
+#[doc(hidden)]
 #[derive(Deref, DerefMut)]
 pub struct AppRef<'a>(Ref<'a, AppContext>);
     }
 }
+#[doc(hidden)]
 #[derive(Deref, DerefMut)]
 pub struct AppRefMut<'a>(RefMut<'a, AppContext>);
     }
 }
+/// A reference to a GPUI application, typically constructed in the `main` function of your app.
+/// You won't interact with this type much outside of initial configuration and startup.
 pub struct App(Rc<AppCell>);
 /// Represents an application before it is fully launched. Once your app is
         self
     }
+    /// Invokes a handler when an already-running application is launched.
+    /// On macOS, this can occur when the application icon is double-clicked or the app is launched via the dock.
     pub fn on_reopen<F>(&self, mut callback: F) -> &Self
     where
         F: 'static + FnMut(&mut AppContext),
         self
     }
+    /// Returns metadata associated with the application
     pub fn metadata(&self) -> AppMetadata {
         self.0.borrow().app_metadata.clone()
     }
+    /// Returns a handle to the [`BackgroundExecutor`] associated with this app, which can be used to spawn futures in the background.
     pub fn background_executor(&self) -> BackgroundExecutor {
         self.0.borrow().background_executor.clone()
     }
+    /// Returns a handle to the [`ForegroundExecutor`] associated with this app, which can be used to spawn futures in the foreground.
     pub fn foreground_executor(&self) -> ForegroundExecutor {
         self.0.borrow().foreground_executor.clone()
     }
+    /// Returns a reference to the [`TextSystem`] associated with this app.
     pub fn text_system(&self) -> Arc<TextSystem> {
         self.0.borrow().text_system.clone()
     }
 type ReleaseListener = Box<dyn FnOnce(&mut dyn Any, &mut AppContext) + 'static>;
 type NewViewListener = Box<dyn FnMut(AnyView, &mut WindowContext) + 'static>;
-// struct FrameConsumer {
-//     next_frame_callbacks: Vec<FrameCallback>,
-//     task: Task<()>,
-//     display_linker
-// }
 pub struct AppContext {
     pub(crate) this: Weak<AppCell>,
     pub(crate) platform: Rc<dyn Platform>,
         app
     }
-    /// Quit the application gracefully. Handlers registered with `ModelContext::on_app_quit`
+    /// Quit the application gracefully. Handlers registered with [`ModelContext::on_app_quit`]
     /// will be given 100ms to complete before exiting.
     pub fn shutdown(&mut self) {
         let mut futures = Vec::new();
         }
     }
+    /// Gracefully quit the application via the platform's standard routine.
     pub fn quit(&mut self) {
         self.platform.quit();
     }
+    /// Get metadata about the app and platform.
     pub fn app_metadata(&self) -> AppMetadata {
         self.app_metadata.clone()
     }
         result
     }
+    /// Arrange a callback to be invoked when the given model or view calls `notify` on its respective context.
     pub fn observe<W, E>(
         &mut self,
         entity: &E,
         })
     }
-    pub fn observe_internal<W, E>(
+    pub(crate) fn observe_internal<W, E>(
         &mut self,
         entity: &E,
         mut on_notify: impl FnMut(E, &mut AppContext) -> bool + 'static,
         subscription
     }
-    pub fn subscribe<T, E, Evt>(
+    /// Arrange for the given callback to be invoked whenever the given model or view emits an event of a given type.
+    /// The callback is provided a handle to the emitting entity and a reference to the emitted event.
+    pub fn subscribe<T, E, Event>(
         &mut self,
         entity: &E,
-        mut on_event: impl FnMut(E, &Evt, &mut AppContext) + 'static,
+        mut on_event: impl FnMut(E, &Event, &mut AppContext) + 'static,
     ) -> Subscription
     where
-        T: 'static + EventEmitter<Evt>,
+        T: 'static + EventEmitter<Event>,
         E: Entity<T>,
-        Evt: 'static,
+        Event: 'static,
     {
         self.subscribe_internal(entity, move |entity, event, cx| {
             on_event(entity, event, cx);
         subscription
     }
+    /// Returns handles to all open windows in the application.
+    /// Each handle could be downcast to a handle typed for the root view of that window.
+    /// To find all windows of a given type, you could filter on
     pub fn windows(&self) -> Vec<AnyWindowHandle> {
         self.windows
             .values()
         self.pending_effects.push_back(effect);
     }
-    /// Called at the end of AppContext::update to complete any side effects
+    /// Called at the end of [`AppContext::update`] to complete any side effects
     /// such as notifying observers, emitting events, etc. Effects can themselves
     /// cause effects, so we continue looping until all effects are processed.
     fn flush_effects(&mut self) {

crates/gpui/src/app/async_context.rs+6−0

 }
 impl AsyncAppContext {
+    /// Schedules all windows in the application to be redrawn.
     pub fn refresh(&mut self) -> Result<()> {
         let app = self
             .app
         Ok(())
     }
+    /// Get an executor which can be used to spawn futures in the background.
     pub fn background_executor(&self) -> &BackgroundExecutor {
         &self.background_executor
     }
+    /// Get an executor which can be used to spawn futures in the foreground.
     pub fn foreground_executor(&self) -> &ForegroundExecutor {
         &self.foreground_executor
     }
+    /// Invoke the given function in the context of the app, then flush any effects produced during its invocation.
     pub fn update<R>(&self, f: impl FnOnce(&mut AppContext) -> R) -> Result<R> {
         let app = self
             .app
         Ok(f(&mut lock))
     }
+    /// Open a window with the given options based on the root view returned by the given function.
     pub fn open_window<V>(
         &self,
         options: crate::WindowOptions,
         Ok(lock.open_window(options, build_root_view))
     }
+    /// Schedule a future to be polled in the background.
     pub fn spawn<Fut, R>(&self, f: impl FnOnce(AsyncAppContext) -> Fut) -> Task<R>
     where
         Fut: Future<Output = R> + 'static,

crates/gpui/src/app/entity_map.rs+4−1

 #[cfg(any(test, feature = "test-support"))]
 use collections::HashMap;
-slotmap::new_key_type! { pub struct EntityId; }
+slotmap::new_key_type! {
+    /// A unique identifier for a model or view across the application.
+    pub struct EntityId;
+}
 impl EntityId {
     pub fn as_u64(self) -> u64 {

crates/gpui/src/app/test_context.rs+76−6

+#![deny(missing_docs)]
 use crate::{
     div, Action, AnyView, AnyWindowHandle, AppCell, AppContext, AsyncAppContext,
     BackgroundExecutor, ClipboardItem, Context, Entity, EventEmitter, ForegroundExecutor,
 use futures::{Stream, StreamExt};
 use std::{future::Future, ops::Deref, rc::Rc, sync::Arc, time::Duration};
+/// A TestAppContext is provided to tests created with `#[gpui::test]`, it provides
+/// an implementation of `Context` with additional methods that are useful in tests.
 #[derive(Clone)]
 pub struct TestAppContext {
+    #[doc(hidden)]
     pub app: Rc<AppCell>,
+    #[doc(hidden)]
     pub background_executor: BackgroundExecutor,
+    #[doc(hidden)]
     pub foreground_executor: ForegroundExecutor,
+    #[doc(hidden)]
     pub dispatcher: TestDispatcher,
-    pub test_platform: Rc<TestPlatform>,
+    test_platform: Rc<TestPlatform>,
     text_system: Arc<TextSystem>,
 }
 }
 impl TestAppContext {
+    /// Creates a new `TestAppContext`. Usually you can rely on `#[gpui::test]` to do this for you.
     pub fn new(dispatcher: TestDispatcher) -> Self {
         let arc_dispatcher = Arc::new(dispatcher.clone());
         let background_executor = BackgroundExecutor::new(arc_dispatcher.clone());
         }
     }
+    /// returns a new `TestAppContext` re-using the same executors to interleave tasks.
     pub fn new_app(&self) -> TestAppContext {
         Self::new(self.dispatcher.clone())
     }
+    /// Simulates quitting the app.
     pub fn quit(&self) {
         self.app.borrow_mut().shutdown();
     }
+    /// Schedules all windows to be redrawn on the next effect cycle.
     pub fn refresh(&mut self) -> Result<()> {
         let mut app = self.app.borrow_mut();
         app.refresh();
         Ok(())
     }
+    /// Returns an executor (for running tasks in the background)
     pub fn executor(&self) -> BackgroundExecutor {
         self.background_executor.clone()
     }
+    /// Returns an executor (for running tasks on the main thread)
     pub fn foreground_executor(&self) -> &ForegroundExecutor {
         &self.foreground_executor
     }
+    /// Gives you an `&mut AppContext` for the duration of the closure
     pub fn update<R>(&self, f: impl FnOnce(&mut AppContext) -> R) -> R {
         let mut cx = self.app.borrow_mut();
         cx.update(f)
     }
+    /// Gives you an `&AppContext` for the duration of the closure
     pub fn read<R>(&self, f: impl FnOnce(&AppContext) -> R) -> R {
         let cx = self.app.borrow();
         f(&*cx)
     }
+    /// Adds a new window. The Window will always be backed by a `TestWindow` which
+    /// can be retrieved with `self.test_window(handle)`
     pub fn add_window<F, V>(&mut self, build_window: F) -> WindowHandle<V>
     where
         F: FnOnce(&mut ViewContext<V>) -> V,
         cx.open_window(WindowOptions::default(), |cx| cx.new_view(build_window))
     }
+    /// Adds a new window with no content.
     pub fn add_empty_window(&mut self) -> AnyWindowHandle {
         let mut cx = self.app.borrow_mut();
         cx.open_window(WindowOptions::default(), |cx| cx.new_view(|_| EmptyView {}))
             .any_handle
     }
+    /// Adds a new window, and returns its root view and a `VisualTestContext` which can be used
+    /// as a `WindowContext` for the rest of the test. Typically you would shadow this context with
+    /// the returned one. `let (view, cx) = cx.add_window_view(...);`
     pub fn add_window_view<F, V>(&mut self, build_window: F) -> (View<V>, &mut VisualTestContext)
     where
         F: FnOnce(&mut ViewContext<V>) -> V,
         (view, Box::leak(cx))
     }
+    /// returns the TextSystem
     pub fn text_system(&self) -> &Arc<TextSystem> {
         &self.text_system
     }
+    /// Simulates writing to the platform clipboard
     pub fn write_to_clipboard(&self, item: ClipboardItem) {
         self.test_platform.write_to_clipboard(item)
     }
+    /// Simulates reading from the platform clipboard.
+    /// This will return the most recent value from `write_to_clipboard`.
     pub fn read_from_clipboard(&self) -> Option<ClipboardItem> {
         self.test_platform.read_from_clipboard()
     }
+    /// Simulates choosing a File in the platform's "Open" dialog.
     pub fn simulate_new_path_selection(
         &self,
         select_path: impl FnOnce(&std::path::Path) -> Option<std::path::PathBuf>,
         self.test_platform.simulate_new_path_selection(select_path);
     }
+    /// Simulates clicking a button in an platform-level alert dialog.
     pub fn simulate_prompt_answer(&self, button_ix: usize) {
         self.test_platform.simulate_prompt_answer(button_ix);
     }
+    /// Returns true if there's an alert dialog open.
     pub fn has_pending_prompt(&self) -> bool {
         self.test_platform.has_pending_prompt()
     }
+    /// Simulates the user resizing the window to the new size.
     pub fn simulate_window_resize(&self, window_handle: AnyWindowHandle, size: Size<Pixels>) {
         self.test_window(window_handle).simulate_resize(size);
     }
+    /// Returns all windows open in the test.
     pub fn windows(&self) -> Vec<AnyWindowHandle> {
         self.app.borrow().windows().clone()
     }
+    /// Run the given task on the main thread.
     pub fn spawn<Fut, R>(&self, f: impl FnOnce(AsyncAppContext) -> Fut) -> Task<R>
     where
         Fut: Future<Output = R> + 'static,
         self.foreground_executor.spawn(f(self.to_async()))
     }
+    /// true if the given global is defined
     pub fn has_global<G: 'static>(&self) -> bool {
         let app = self.app.borrow();
         app.has_global::<G>()
     }
+    /// runs the given closure with a reference to the global
+    /// panics if `has_global` would return false.
     pub fn read_global<G: 'static, R>(&self, read: impl FnOnce(&G, &AppContext) -> R) -> R {
         let app = self.app.borrow();
         read(app.global(), &app)
     }
+    /// runs the given closure with a reference to the global (if set)
     pub fn try_read_global<G: 'static, R>(
         &self,
         read: impl FnOnce(&G, &AppContext) -> R,
         Some(read(lock.try_global()?, &lock))
     }
+    /// sets the global in this context.
     pub fn set_global<G: 'static>(&mut self, global: G) {
         let mut lock = self.app.borrow_mut();
         lock.set_global(global);
     }
+    /// updates the global in this context. (panics if `has_global` would return false)
     pub fn update_global<G: 'static, R>(
         &mut self,
         update: impl FnOnce(&mut G, &mut AppContext) -> R,
         lock.update_global(update)
     }
+    /// Returns an `AsyncAppContext` which can be used to run tasks that expect to be on a background
+    /// thread on the current thread in tests.
     pub fn to_async(&self) -> AsyncAppContext {
         AsyncAppContext {
             app: Rc::downgrade(&self.app),
         }
     }
+    /// Wait until there are no more pending tasks.
     pub fn run_until_parked(&mut self) {
         self.background_executor.run_until_parked()
     }
+    /// Simulate dispatching an action to the currently focused node in the window.
     pub fn dispatch_action<A>(&mut self, window: AnyWindowHandle, action: A)
     where
         A: Action,
     /// simulate_keystrokes takes a space-separated list of keys to type.
     /// cx.simulate_keystrokes("cmd-shift-p b k s p enter")
-    /// will run backspace on the current editor through the command palette.
+    /// in Zed, this will run backspace on the current editor through the command palette.
+    /// This will also run the background executor until it's parked.
     pub fn simulate_keystrokes(&mut self, window: AnyWindowHandle, keystrokes: &str) {
         for keystroke in keystrokes
             .split(" ")
     /// simulate_input takes a string of text to type.
     /// cx.simulate_input("abc")
-    /// will type abc into your current editor.
+    /// will type abc into your current editor
+    /// This will also run the background executor until it's parked.
     pub fn simulate_input(&mut self, window: AnyWindowHandle, input: &str) {
         for keystroke in input.split("").map(Keystroke::parse).map(Result::unwrap) {
             self.dispatch_keystroke(window, keystroke.into(), false);
         self.background_executor.run_until_parked()
     }
+    /// dispatches a single Keystroke (see also `simulate_keystrokes` and `simulate_input`)
     pub fn dispatch_keystroke(
         &mut self,
         window: AnyWindowHandle,
             .simulate_keystroke(keystroke, is_held)
     }
+    /// Returns the `TestWindow` backing the given handle.
     pub fn test_window(&self, window: AnyWindowHandle) -> TestWindow {
         self.app
             .borrow_mut()
             .clone()
     }
+    /// Returns a stream of notifications whenever the View or Model is updated.
     pub fn notifications<T: 'static>(&mut self, entity: &impl Entity<T>) -> impl Stream<Item = ()> {
         let (tx, rx) = futures::channel::mpsc::unbounded();
         self.update(|cx| {
         rx
     }
+    /// Retuens a stream of events emitted by the given Model.
     pub fn events<Evt, T: 'static + EventEmitter<Evt>>(
         &mut self,
         entity: &Model<T>,
         rx
     }
+    /// Runs until the given condition becomes true. (Prefer `run_until_parked` if you
+    /// don't need to jump in at a specific time).
     pub async fn condition<T: 'static>(
         &mut self,
         model: &Model<T>,
 }
 impl<T: Send> Model<T> {
+    /// Block until the next event is emitted by the model, then return it.
     pub fn next_event<Evt>(&self, cx: &mut TestAppContext) -> Evt
     where
         Evt: Send + Clone + 'static,
 }
 impl<V: 'static> View<V> {
+    /// Returns a future that resolves when the view is next updated.
     pub fn next_notification(&self, cx: &TestAppContext) -> impl Future<Output = ()> {
         use postage::prelude::{Sink as _, Stream as _};
 }
 impl<V> View<V> {
+    /// Returns a future that resolves when the condition becomes true.
     pub fn condition<Evt>(
         &self,
         cx: &TestAppContext,
                         }
                     }
-                    // todo!(start_waiting)
+                    cx.borrow().background_executor().start_waiting();
-                    // cx.borrow().foreground_executor().start_waiting();
                     rx.recv()
                         .await
                         .expect("view dropped with pending condition");
-                    // cx.borrow().foreground_executor().finish_waiting();
+                    cx.borrow().background_executor().finish_waiting();
                 }
             })
             .await
 use derive_more::{Deref, DerefMut};
 #[derive(Deref, DerefMut, Clone)]
+/// A VisualTestContext is the test-equivalent of a `WindowContext`. It allows you to
+/// run window-specific test code.
 pub struct VisualTestContext {
     #[deref]
     #[deref_mut]
 }
 impl<'a> VisualTestContext {
+    /// Provides the `WindowContext` for the duration of the closure.
     pub fn update<R>(&mut self, f: impl FnOnce(&mut WindowContext) -> R) -> R {
         self.cx.update_window(self.window, |_, cx| f(cx)).unwrap()
     }
+    /// Create a new VisualTestContext. You would typically shadow the passed in
+    /// TestAppContext with this, as this is typically more useful.
+    /// `let cx = VisualTestContext::from_window(window, cx);`
     pub fn from_window(window: AnyWindowHandle, cx: &TestAppContext) -> Self {
         Self {
             cx: cx.clone(),
         }
     }
+    /// Wait until there are no more pending tasks.
     pub fn run_until_parked(&self) {
         self.cx.background_executor.run_until_parked();
     }
+    /// Dispatch the action to the currently focused node.
     pub fn dispatch_action<A>(&mut self, action: A)
     where
         A: Action,
         self.cx.dispatch_action(self.window, action)
     }
+    /// Read the title off the window (set by `WindowContext#set_window_title`)
     pub fn window_title(&mut self) -> Option<String> {
         self.cx.test_window(self.window).0.lock().title.clone()
     }
+    /// Simulate a sequence of keystrokes `cx.simulate_keystrokes("cmd-p escape")`
+    /// Automatically runs until parked.
     pub fn simulate_keystrokes(&mut self, keystrokes: &str) {
         self.cx.simulate_keystrokes(self.window, keystrokes)
     }
+    /// Simulate typing text `cx.simulate_input("hello")`
+    /// Automatically runs until parked.
     pub fn simulate_input(&mut self, input: &str) {
         self.cx.simulate_input(self.window, input)
     }
+    /// Simulates the user blurring the window.
     pub fn deactivate_window(&mut self) {
         if Some(self.window) == self.test_platform.active_window() {
             self.test_platform.set_active_window(None)
         }
         self.background_executor.run_until_parked();
     }
+    /// Simulates the user closing the window.
     /// Returns true if the window was closed.
     pub fn simulate_close(&mut self) -> bool {
         let handler = self
 }
 impl AnyWindowHandle {
+    /// Creates the given view in this window.
     pub fn build_view<V: Render + 'static>(
         &self,
         cx: &mut TestAppContext,
     }
 }
+/// An EmptyView for testing.
 pub struct EmptyView {}
 impl Render for EmptyView {

crates/gpui/src/element.rs+5−5

crates/gpui/src/elements/img.rs+4−4

@@ -2,7 +2,7 @@ use std::sync::Arc; · 1 unmodified line
2		2
3	use crate::{	3	use crate::{
4	point, size, BorrowWindow, Bounds, DevicePixels, Element, ImageData, InteractiveElement,	4	point, size, BorrowWindow, Bounds, DevicePixels, Element, ImageData, InteractiveElement,
5	InteractiveElementState, Interactivity, IntoElement, LayoutId, Pixels, SharedString, Size,	5	InteractiveElementState, Interactivity, IntoElement, LayoutId, Pixels, SharedUrl, Size,
6	StyleRefinement, Styled, WindowContext,	6	StyleRefinement, Styled, WindowContext,
7	};	7	};
8	use futures::FutureExt;	8	use futures::FutureExt;
@@ -12,13 +12,13 @@ use util::ResultExt; · 3 unmodified lines
12	#[derive(Clone, Debug)]	12	#[derive(Clone, Debug)]
13	pub enum ImageSource {	13	pub enum ImageSource {
14	/// Image content will be loaded from provided URI at render time.	14	/// Image content will be loaded from provided URI at render time.
15	Uri(SharedString),	15	Uri(SharedUrl),
16	Data(Arc<ImageData>),	16	Data(Arc<ImageData>),
17	Surface(CVImageBuffer),	17	Surface(CVImageBuffer),
18	}	18	}
19		19
20	impl From<SharedString> for ImageSource {	20	impl From<SharedUrl> for ImageSource {
21	fn from(value: SharedString) -> Self {	21	fn from(value: SharedUrl) -> Self {
22	Self::Uri(value)	22	Self::Uri(value)
23	}	23	}
24	}	24	}

crates/gpui/src/elements/overlay.rs+1−1

     children: SmallVec<[AnyElement; 2]>,
     anchor_corner: AnchorCorner,
     fit_mode: OverlayFitMode,
-    // todo!();
     anchor_position: Option<Point<Pixels>>,
+    // todo!();
     // position_mode: OverlayPositionMode,
 }

crates/gpui/src/executor.rs+42−2

     not_send: PhantomData<Rc<()>>,
 }
+/// Task is a primitive that allows work to happen in the background.
+///
+/// It implements [`Future`] so you can `.await` on it.
+///
+/// If you drop a task it will be cancelled immediately. Calling [`Task::detach`] allows
+/// the task to continue running in the background, but with no way to return a value.
 #[must_use]
 #[derive(Debug)]
 pub enum Task<T> {
 }
 impl<T> Task<T> {
+    /// Create a new task that will resolve with the value
     pub fn ready(val: T) -> Self {
         Task::Ready(Some(val))
     }
+    /// Detaching a task runs it to completion in the background
     pub fn detach(self) {
         match self {
             Task::Ready(_) => {}
     T: 'static,
     E: 'static + Debug,
 {
+    /// Run the task to completion in the background and log any
+    /// errors that occur.
     #[track_caller]
     pub fn detach_and_log_err(self, cx: &mut AppContext) {
         let location = core::panic::Location::caller();
 type AnyFuture<R> = Pin<Box<dyn 'static + Send + Future<Output = R>>>;
+/// BackgroundExecutor lets you run things on background threads.
+/// In production this is a thread pool with no ordering guarantees.
+/// In tests this is simalated by running tasks one by one in a deterministic
+/// (but arbitrary) order controlled by the `SEED` environment variable.
 impl BackgroundExecutor {
     pub fn new(dispatcher: Arc<dyn PlatformDispatcher>) -> Self {
         Self { dispatcher }
         Task::Spawned(task)
     }
+    /// Used by the test harness to run an async test in a syncronous fashion.
     #[cfg(any(test, feature = "test-support"))]
     #[track_caller]
     pub fn block_test<R>(&self, future: impl Future<Output = R>) -> R {
         }
     }
+    /// Block the current thread until the given future resolves.
+    /// Consider using `block_with_timeout` instead.
     pub fn block<R>(&self, future: impl Future<Output = R>) -> R {
         if let Ok(value) = self.block_internal(true, future, usize::MAX) {
             value
         }
     }
+    /// Block the current thread until the given future resolves
+    /// or `duration` has elapsed.
     pub fn block_with_timeout<R>(
         &self,
         duration: Duration,
         }
     }
+    /// Scoped lets you start a number of tasks and waits
+    /// for all of them to complete before returning.
     pub async fn scoped<'scope, F>(&self, scheduler: F)
     where
         F: FnOnce(&mut Scope<'scope>),
         }
     }
+    /// Returns a task that will complete after the given duration.
+    /// Depending on other concurrent tasks the elapsed duration may be longer
+    /// than reqested.
     pub fn timer(&self, duration: Duration) -> Task<()> {
         let (runnable, task) = async_task::spawn(async move {}, {
             let dispatcher = self.dispatcher.clone();
         Task::Spawned(task)
     }
+    /// in tests, start_waiting lets you indicate which task is waiting (for debugging only)
     #[cfg(any(test, feature = "test-support"))]
     pub fn start_waiting(&self) {
         self.dispatcher.as_test().unwrap().start_waiting();
     }
+    /// in tests, removes the debugging data added by start_waiting
     #[cfg(any(test, feature = "test-support"))]
     pub fn finish_waiting(&self) {
         self.dispatcher.as_test().unwrap().finish_waiting();
     }
+    /// in tests, run an arbitrary number of tasks (determined by the SEED environment variable)
     #[cfg(any(test, feature = "test-support"))]
     pub fn simulate_random_delay(&self) -> impl Future<Output = ()> {
         self.dispatcher.as_test().unwrap().simulate_random_delay()
     }
+    /// in tests, indicate that a given task from `spawn_labeled` should run after everything else
     #[cfg(any(test, feature = "test-support"))]
     pub fn deprioritize(&self, task_label: TaskLabel) {
         self.dispatcher.as_test().unwrap().deprioritize(task_label)
     }
+    /// in tests, move time forward. This does not run any tasks, but does make `timer`s ready.
     #[cfg(any(test, feature = "test-support"))]
     pub fn advance_clock(&self, duration: Duration) {
         self.dispatcher.as_test().unwrap().advance_clock(duration)
     }
+    /// in tests, run one task.
     #[cfg(any(test, feature = "test-support"))]
     pub fn tick(&self) -> bool {
         self.dispatcher.as_test().unwrap().tick(false)
     }
+    /// in tests, run all tasks that are ready to run. If after doing so
+    /// the test still has outstanding tasks, this will panic. (See also `allow_parking`)
     #[cfg(any(test, feature = "test-support"))]
     pub fn run_until_parked(&self) {
         self.dispatcher.as_test().unwrap().run_until_parked()
     }
+    /// in tests, prevents `run_until_parked` from panicking if there are outstanding tasks.
+    /// This is useful when you are integrating other (non-GPUI) futures, like disk access, that
+    /// do take real async time to run.
     #[cfg(any(test, feature = "test-support"))]
     pub fn allow_parking(&self) {
         self.dispatcher.as_test().unwrap().allow_parking();
     }
+    /// in tests, returns the rng used by the dispatcher and seeded by the `SEED` environment variable
     #[cfg(any(test, feature = "test-support"))]
     pub fn rng(&self) -> StdRng {
         self.dispatcher.as_test().unwrap().rng()
     }
+    /// How many CPUs are available to the dispatcher
     pub fn num_cpus(&self) -> usize {
         num_cpus::get()
     }
+    /// Whether we're on the main thread.
     pub fn is_main_thread(&self) -> bool {
         self.dispatcher.is_main_thread()
     }
     #[cfg(any(test, feature = "test-support"))]
+    /// in tests, control the number of ticks that `block_with_timeout` will run before timing out.
     pub fn set_block_on_ticks(&self, range: std::ops::RangeInclusive<usize>) {
         self.dispatcher.as_test().unwrap().set_block_on_ticks(range);
     }
 }
+/// ForegroundExecutor runs things on the main thread.
 impl ForegroundExecutor {
     pub fn new(dispatcher: Arc<dyn PlatformDispatcher>) -> Self {
         Self {
         }
     }
-    /// Enqueues the given closure to be run on any thread. The closure returns
+    /// Enqueues the given Task to run on the main thread at some point in the future.
-    /// a future which will be run to completion on any available thread.
     pub fn spawn<R>(&self, future: impl Future<Output = R> + 'static) -> Task<R>
     where
         R: 'static,
     }
 }
+/// Scope manages a set of tasks that are enqueued and waited on together. See [`BackgroundExecutor::scoped`].
 pub struct Scope<'a> {
     executor: BackgroundExecutor,
     futures: Vec<Pin<Box<dyn Future<Output = ()> + Send + 'static>>>,

crates/gpui/src/gpui.rs+2−0

 pub mod prelude;
 mod scene;
 mod shared_string;
+mod shared_url;
 mod style;
 mod styled;
 mod subscription;
 pub use scene::*;
 use seal::Sealed;
 pub use shared_string::*;
+pub use shared_url::*;
 pub use smol::Timer;
 pub use style::*;
 pub use styled::*;

crates/gpui/src/image_cache.rs+3−3

@@ -1,4 +1,4 @@
1	use crate::{ImageData, ImageId, SharedString};	1	use crate::{ImageData, ImageId, SharedUrl};
2	use collections::HashMap;	2	use collections::HashMap;
3	use futures::{	3	use futures::{
4	future::{BoxFuture, Shared},	4	future::{BoxFuture, Shared},
@@ -44,7 +44,7 @@ impl From<ImageError> for Error { · 39 unmodified lines
44		44
45	pub struct ImageCache {	45	pub struct ImageCache {
46	client: Arc<dyn HttpClient>,	46	client: Arc<dyn HttpClient>,
47	images: Arc<Mutex<HashMap<SharedString, FetchImageFuture>>>,	47	images: Arc<Mutex<HashMap<SharedUrl, FetchImageFuture>>>,
48	}	48	}
49		49
50	type FetchImageFuture = Shared<BoxFuture<'static, Result<Arc<ImageData>, Error>>>;	50	type FetchImageFuture = Shared<BoxFuture<'static, Result<Arc<ImageData>, Error>>>;
@@ -59,7 +59,7 @@ impl ImageCache { · 8 unmodified lines
59		59
60	pub fn get(	60	pub fn get(
61	&self,	61	&self,
62	uri: impl Into<SharedString>,	62	uri: impl Into<SharedUrl>,
63	) -> Shared<BoxFuture<'static, Result<Arc<ImageData>, Error>>> {	63	) -> Shared<BoxFuture<'static, Result<Arc<ImageData>, Error>>> {
64	let uri = uri.into();	64	let uri = uri.into();
65	let mut images = self.images.lock();	65	let mut images = self.images.lock();

crates/gpui/src/input.rs+1−1

@@ -34,7 +34,7 @@ pub trait InputHandler: 'static + Sized { · 33 unmodified lines
34	) -> Option<Bounds<Pixels>>;	34	) -> Option<Bounds<Pixels>>;
35	}	35	}
36		36
37	/// The canonical implementation of `PlatformInputHandler`. Call `WindowContext::handle_input`	37	/// The canonical implementation of [`PlatformInputHandler`]. Call [`WindowContext::handle_input`]
38	/// with an instance during your element's paint.	38	/// with an instance during your element's paint.
39	pub struct ElementInputHandler<V> {	39	pub struct ElementInputHandler<V> {
40	view: View<V>,	40	view: View<V>,

crates/gpui/src/interactive.rs+14−0

@@ -178,6 +178,20 @@ impl ScrollDelta { · 177 unmodified lines
178	ScrollDelta::Lines(delta) => point(line_height * delta.x, line_height * delta.y),	178	ScrollDelta::Lines(delta) => point(line_height * delta.x, line_height * delta.y),
179	}	179	}
180	}	180	}
		181
		182	pub fn coalesce(self, other: ScrollDelta) -> ScrollDelta {
		183	match (self, other) {
		184	(ScrollDelta::Pixels(px_a), ScrollDelta::Pixels(px_b)) => {
		185	ScrollDelta::Pixels(px_a + px_b)
		186	}
		187
		188	(ScrollDelta::Lines(lines_a), ScrollDelta::Lines(lines_b)) => {
		189	ScrollDelta::Lines(lines_a + lines_b)
		190	}
		191
		192	_ => other,
		193	}
		194	}
181	}	195	}
182		196
183	#[derive(Clone, Debug, Default)]	197	#[derive(Clone, Debug, Default)]

crates/gpui/src/key_dispatch.rs+75−2

@@ -192,8 +192,8 @@ impl DispatchTree { · 191 unmodified lines
192	keymap	192	keymap
193	.bindings_for_action(action)	193	.bindings_for_action(action)
194	.filter(\|binding\| {	194	.filter(\|binding\| {
195	for i in 1..context_stack.len() {	195	for i in 0..context_stack.len() {
196	let context = &context_stack[0..i];	196	let context = &context_stack[0..=i];
197	if keymap.binding_enabled(binding, context) {	197	if keymap.binding_enabled(binding, context) {
198	return true;	198	return true;
199	}	199	}
@@ -283,3 +283,76 @@ impl DispatchTree { · 83 unmodified lines
283	*self.node_stack.last().unwrap()	283	*self.node_stack.last().unwrap()
284	}	284	}
285	}	285	}
		286
		287	#[cfg(test)]
		288	mod tests {
		289	use std::{rc::Rc, sync::Arc};
		290
		291	use parking_lot::Mutex;
		292
		293	use crate::{Action, ActionRegistry, DispatchTree, KeyBinding, KeyContext, Keymap};
		294
		295	#[derive(PartialEq, Eq)]
		296	struct TestAction;
		297
		298	impl Action for TestAction {
		299	fn name(&self) -> &'static str {
		300	"test::TestAction"
		301	}
		302
		303	fn debug_name() -> &'static str
		304	where
		305	Self: ::std::marker::Sized,
		306	{
		307	"test::TestAction"
		308	}
		309
		310	fn partial_eq(&self, action: &dyn Action) -> bool {
		311	action
		312	.as_any()
		313	.downcast_ref::<Self>()
		314	.map_or(false, \|a\| self == a)
		315	}
		316
		317	fn boxed_clone(&self) -> std::boxed::Box<dyn Action> {
		318	Box::new(TestAction)
		319	}
		320
		321	fn as_any(&self) -> &dyn ::std::any::Any {
		322	self
		323	}
		324
		325	fn build(_value: serde_json::Value) -> anyhow::Result<Box<dyn Action>>
		326	where
		327	Self: Sized,
		328	{
		329	Ok(Box::new(TestAction))
		330	}
		331	}
		332
		333	#[test]
		334	fn test_keybinding_for_action_bounds() {
		335	let keymap = Keymap::new(vec![KeyBinding::new(
		336	"cmd-n",
		337	TestAction,
		338	Some("ProjectPanel"),
		339	)]);
		340
		341	let mut registry = ActionRegistry::default();
		342
		343	registry.load_action::<TestAction>();
		344
		345	let keymap = Arc::new(Mutex::new(keymap));
		346
		347	let tree = DispatchTree::new(keymap, Rc::new(registry));
		348
		349	let contexts = vec![
		350	KeyContext::parse("Workspace").unwrap(),
		351	KeyContext::parse("ProjectPanel").unwrap(),
		352	];
		353
		354	let keybinding = tree.bindings_for_action(&TestAction, &contexts);
		355
		356	assert!(keybinding[0].action.partial_eq(&TestAction))
		357	}
		358	}

crates/gpui/src/platform/mac/display.rs+2−2

@@ -14,12 +14,12 @@ pub struct MacDisplay(pub(crate) CGDirectDisplayID); · 13 unmodified lines
14	unsafe impl Send for MacDisplay {}	14	unsafe impl Send for MacDisplay {}
15		15
16	impl MacDisplay {	16	impl MacDisplay {
17	/// Get the screen with the given [DisplayId].	17	/// Get the screen with the given [`DisplayId`].
18	pub fn find_by_id(id: DisplayId) -> Option<Self> {	18	pub fn find_by_id(id: DisplayId) -> Option<Self> {
19	Self::all().find(\|screen\| screen.id() == id)	19	Self::all().find(\|screen\| screen.id() == id)
20	}	20	}
21		21
22	/// Get the screen with the given persistent [Uuid].	22	/// Get the screen with the given persistent [`Uuid`].
23	pub fn find_by_uuid(uuid: Uuid) -> Option<Self> {	23	pub fn find_by_uuid(uuid: Uuid) -> Option<Self> {
24	Self::all().find(\|screen\| screen.uuid().ok() == Some(uuid))	24	Self::all().find(\|screen\| screen.uuid().ok() == Some(uuid))
25	}	25	}

crates/gpui/src/platform/test/display.rs+1−1

@@ -32,7 +32,7 @@ impl PlatformDisplay for TestDisplay { · 31 unmodified lines
32	}	32	}
33		33
34	fn as_any(&self) -> &dyn std::any::Any {	34	fn as_any(&self) -> &dyn std::any::Any {
35	todo!()	35	unimplemented!()
36	}	36	}
37		37
38	fn bounds(&self) -> crate::Bounds<crate::GlobalPixels> {	38	fn bounds(&self) -> crate::Bounds<crate::GlobalPixels> {

crates/gpui/src/platform/test/platform.rs+1−1

     time::Duration,
 };
+/// TestPlatform implements the Platform trait for use in tests.
 pub struct TestPlatform {
     background_executor: BackgroundExecutor,
     foreground_executor: ForegroundExecutor,
     }
 }
-// todo!("implement out what our tests needed in GPUI 1")
 impl Platform for TestPlatform {
     fn background_executor(&self) -> BackgroundExecutor {
         self.background_executor.clone()

crates/gpui/src/shared_url.rs+25−0

@@ -0,0 +1,25 @@
	1	use derive_more::{Deref, DerefMut};
	2
	3	use crate::SharedString;
	4
	5	/// A [`SharedString`] containing a URL.
	6	#[derive(Deref, DerefMut, Default, PartialEq, Eq, Hash, Clone)]
	7	pub struct SharedUrl(SharedString);
	8
	9	impl std::fmt::Debug for SharedUrl {
	10	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	11	self.0.fmt(f)
	12	}
	13	}
	14
	15	impl std::fmt::Display for SharedUrl {
	16	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	17	write!(f, "{}", self.0.as_ref())
	18	}
	19	}
	20
	21	impl<T: Into<SharedString>> From<T> for SharedUrl {
	22	fn from(value: T) -> Self {
	23	Self(value.into())
	24	}
	25	}

crates/gpui/src/subscription.rs+3−3

@@ -37,10 +37,10 @@ where · 36 unmodified lines
37	})))	37	})))
38	}	38	}
39		39
40	/// Inserts a new `[Subscription]` for the given `emitter_key`. By default, subscriptions	40	/// Inserts a new [`Subscription`] for the given `emitter_key`. By default, subscriptions
41	/// are inert, meaning that they won't be listed when calling `[SubscriberSet::remove]` or `[SubscriberSet::retain]`.	41	/// are inert, meaning that they won't be listed when calling `[SubscriberSet::remove]` or `[SubscriberSet::retain]`.
42	/// This method returns a tuple of a `[Subscription]` and an `impl FnOnce`, and you can use the latter	42	/// This method returns a tuple of a [`Subscription`] and an `impl FnOnce`, and you can use the latter
43	/// to activate the `[Subscription]`.	43	/// to activate the [`Subscription`].
44	#[must_use]	44	#[must_use]
45	pub fn insert(	45	pub fn insert(
46	&self,	46	&self,

crates/gpui/src/test.rs+28−0

@@ -1,3 +1,30 @@
		1	//! Test support for GPUI.
		2	//!
		3	//! GPUI provides first-class support for testing, which includes a macro to run test that rely on having a context,
		4	//! and a test implementation of the `ForegroundExecutor` and `BackgroundExecutor` which ensure that your tests run
		5	//! deterministically even in the face of arbitrary parallelism.
		6	//!
		7	//! The output of the `gpui::test` macro is understood by other rust test runners, so you can use it with `cargo test`
		8	//! or `cargo-nextest`, or another runner of your choice.
		9	//!
		10	//! To make it possible to test collaborative user interfaces (like Zed) you can ask for as many different contexts
		11	//! as you need.
		12	//!
		13	//! ## Example
		14	//!
		15	//! ```
		16	//! use gpui;
		17	//!
		18	//! #[gpui::test]
		19	//! async fn test_example(cx: &TestAppContext) {
		20	//! assert!(true)
		21	//! }
		22	//!
		23	//! #[gpui::test]
		24	//! async fn test_collaboration_example(cx_a: &TestAppContext, cx_b: &TestAppContext) {
		25	//! assert!(true)
		26	//! }
		27	//! ```
1	use crate::{Entity, Subscription, TestAppContext, TestDispatcher};	28	use crate::{Entity, Subscription, TestAppContext, TestDispatcher};
2	use futures::StreamExt as _;	29	use futures::StreamExt as _;
3	use rand::prelude::*;	30	use rand::prelude::*;
@@ -68,6 +95,7 @@ impl<T: 'static> futures::Stream for Observation<T> { · 64 unmodified lines
68	}	95	}
69	}	96	}
70		97
		98	/// observe returns a stream of the change events from the given `View` or `Model`
71	pub fn observe<T: 'static>(entity: &impl Entity<T>, cx: &mut TestAppContext) -> Observation<()> {	99	pub fn observe<T: 'static>(entity: &impl Entity<T>, cx: &mut TestAppContext) -> Observation<()> {
72	let (tx, rx) = smol::channel::unbounded();	100	let (tx, rx) = smol::channel::unbounded();
73	let _subscription = cx.update(\|cx\| {	101	let _subscription = cx.update(\|cx\| {

crates/gpui/src/window.rs+142−12

+#![deny(missing_docs)]
 use crate::{
     px, size, transparent_black, Action, AnyDrag, AnyView, AppContext, Arena, ArenaBox, ArenaRef,
     AsyncWindowContext, AvailableSpace, Bounds, BoxShadow, Context, Corners, CursorStyle,
 }
 impl DispatchPhase {
+    /// Returns true if this represents the "bubble" phase.
     pub fn bubble(self) -> bool {
         self == DispatchPhase::Bubble
     }
+    /// Returns true if this represents the "capture" phase.
     pub fn capture(self) -> bool {
         self == DispatchPhase::Capture
     }
     current_focus_path: SmallVec<[FocusId; 8]>,
 }
-slotmap::new_key_type! { pub struct FocusId; }
+slotmap::new_key_type! {
+    /// A globally unique identifier for a focusable element.
+    pub struct FocusId;
+}
 thread_local! {
     pub(crate) static ELEMENT_ARENA: RefCell<Arena> = RefCell::new(Arena::new(4 * 1024 * 1024));
 /// FocusableView allows users of your view to easily
 /// focus it (using cx.focus_view(view))
 pub trait FocusableView: 'static + Render {
+    /// Returns the focus handle associated with this view.
     fn focus_handle(&self, cx: &AppContext) -> FocusHandle;
 }
 impl<M: FocusableView + EventEmitter<DismissEvent>> ManagedView for M {}
+/// Emitted by implementers of [`ManagedView`] to indicate the view should be dismissed, such as when a view is presented as a modal.
 pub struct DismissEvent;
 // Holds the state for a specific window.
+#[doc(hidden)]
 pub struct Window {
     pub(crate) handle: AnyWindowHandle,
     pub(crate) removed: bool,
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 #[repr(C)]
 pub struct ContentMask<P: Clone + Default + Debug> {
+    /// The bounds
     pub bounds: Bounds<P>,
 }
 }
 /// Provides access to application state in the context of a single window. Derefs
-/// to an `AppContext`, so you can also pass a `WindowContext` to any method that takes
+/// to an [`AppContext`], so you can also pass a [`WindowContext`] to any method that takes
-/// an `AppContext` and call any `AppContext` methods.
+/// an [`AppContext`] and call any [`AppContext`] methods.
 pub struct WindowContext<'a> {
     pub(crate) app: &'a mut AppContext,
     pub(crate) window: &'a mut Window,
         self.window.removed = true;
     }
-    /// Obtain a new `FocusHandle`, which allows you to track and manipulate the keyboard focus
+    /// Obtain a new [`FocusHandle`], which allows you to track and manipulate the keyboard focus
     /// for elements rendered within this window.
     pub fn focus_handle(&mut self) -> FocusHandle {
         FocusHandle::new(&self.window.focus_handles)
     }
-    /// Obtain the currently focused `FocusHandle`. If no elements are focused, returns `None`.
+    /// Obtain the currently focused [`FocusHandle`]. If no elements are focused, returns `None`.
     pub fn focused(&self) -> Option<FocusHandle> {
         self.window
             .focus
             .and_then(|id| FocusHandle::for_id(id, &self.window.focus_handles))
     }
-    /// Move focus to the element associated with the given `FocusHandle`.
+    /// Move focus to the element associated with the given [`FocusHandle`].
     pub fn focus(&mut self, handle: &FocusHandle) {
         if !self.window.focus_enabled || self.window.focus == Some(handle.id) {
             return;
         self.notify();
     }
+    /// Blur the window and don't allow anything in it to be focused again.
     pub fn disable_focus(&mut self) {
         self.blur();
         self.window.focus_enabled = false;
     }
+    /// Dispatch the given action on the currently focused element.
     pub fn dispatch_action(&mut self, action: Box<dyn Action>) {
         let focus_handle = self.focused();
         });
     }
+    /// Subscribe to events emitted by a model or view.
+    /// The entity to which you're subscribing must implement the [`EventEmitter`] trait.
+    /// The callback will be invoked a handle to the emitting entity (either a [`View`] or [`Model`]), the event, and a window context for the current window.
     pub fn subscribe<Emitter, E, Evt>(
         &mut self,
         entity: &E,
             .request_measured_layout(style, rem_size, measure)
     }
+    /// Compute the layout for the given id within the given available space.
+    /// This method is called for its side effect, typically by the framework prior to painting.
+    /// After calling it, you can request the bounds of the given layout node id or any descendant.
     pub fn compute_layout(&mut self, layout_id: LayoutId, available_space: Size<AvailableSpace>) {
         let mut layout_engine = self.window.layout_engine.take().unwrap();
         layout_engine.compute_layout(layout_id, available_space, self);
             .retain(&(), |callback| callback(self));
     }
+    /// Returns the bounds of the current window in the global coordinate space, which could span across multiple displays.
     pub fn window_bounds(&self) -> WindowBounds {
         self.window.bounds
     }
+    /// Returns the size of the drawable area within the window.
     pub fn viewport_size(&self) -> Size<Pixels> {
         self.window.viewport_size
     }
+    /// Returns whether this window is focused by the operating system (receiving key events).
     pub fn is_window_active(&self) -> bool {
         self.window.active
     }
+    /// Toggle zoom on the window.
     pub fn zoom_window(&self) {
         self.window.platform_window.zoom();
     }
+    /// Update the window's title at the platform level.
     pub fn set_window_title(&mut self, title: &str) {
         self.window.platform_window.set_title(title);
     }
+    /// Mark the window as dirty at the platform level.
     pub fn set_window_edited(&mut self, edited: bool) {
         self.window.platform_window.set_edited(edited);
     }
+    /// Determine the display on which the window is visible.
     pub fn display(&self) -> Option<Rc<dyn PlatformDisplay>> {
         self.platform
             .displays()
             .find(|display| display.id() == self.window.display_id)
     }
+    /// Show the platform character palette.
     pub fn show_character_palette(&self) {
         self.window.platform_window.show_character_palette();
     }
             .on_action(action_type, ArenaRef::from(listener));
     }
+    /// Determine whether the given action is available along the dispatch path to the currently focused element.
     pub fn is_action_available(&self, action: &dyn Action) -> bool {
         let target = self
             .focused()
         self.window.modifiers
     }
+    /// Update the cursor style at the platform level.
     pub fn set_cursor_style(&mut self, style: CursorStyle) {
         self.window.requested_cursor_style = Some(style)
     }
         true
     }
-    pub fn was_top_layer_under_active_drag(
+    pub(crate) fn was_top_layer_under_active_drag(
         &self,
         point: &Point<Pixels>,
         level: &StackingOrder,
         self.dispatch_keystroke_observers(event, None);
     }
+    /// Determine whether a potential multi-stroke key binding is in progress on this window.
     pub fn has_pending_keystrokes(&self) -> bool {
         self.window
             .rendered_frame
         subscription
     }
+    /// Focus the current window and bring it to the foreground at the platform level.
     pub fn activate_window(&self) {
         self.window.platform_window.activate();
     }
+    /// Minimize the current window at the platform level.
     pub fn minimize_window(&self) {
         self.window.platform_window.minimize();
     }
+    /// Toggle full screen status on the current window at the platform level.
     pub fn toggle_full_screen(&self) {
         self.window.platform_window.toggle_full_screen();
     }
+    /// Present a platform dialog.
+    /// The provided message will be presented, along with buttons for each answer.
+    /// When a button is clicked, the returned Receiver will receive the index of the clicked button.
     pub fn prompt(
         &self,
         level: PromptLevel,
-        msg: &str,
+        message: &str,
         answers: &[&str],
     ) -> oneshot::Receiver<usize> {
-        self.window.platform_window.prompt(level, msg, answers)
+        self.window.platform_window.prompt(level, message, answers)
     }
+    /// Returns all available actions for the focused element.
     pub fn available_actions(&self) -> Vec<Box<dyn Action>> {
         let node_id = self
             .window
             .available_actions(node_id)
     }
+    /// Returns key bindings that invoke the given action on the currently focused element.
     pub fn bindings_for_action(&self, action: &dyn Action) -> Vec<KeyBinding> {
         self.window
             .rendered_frame
             )
     }
+    /// Returns any bindings that would invoke the given action on the given focus handle if it were focused.
     pub fn bindings_for_action_in(
         &self,
         action: &dyn Action,
         dispatch_tree.bindings_for_action(action, &context_stack)
     }
+    /// Returns a generic event listener that invokes the given listener with the view and context associated with the given view handle.
     pub fn listener_for<V: Render, E>(
         &self,
         view: &View<V>,
         }
     }
+    /// Returns a generic handler that invokes the given handler with the view and context associated with the given view handle.
     pub fn handler_for<V: Render>(
         &self,
         view: &View<V>,
         }
     }
-    //========== ELEMENT RELATED FUNCTIONS ===========
+    /// Invoke the given function with the given focus handle present on the key dispatch stack.
+    /// If you want an element to participate in key dispatch, use this method to push its key context and focus handle into the stack during paint.
     pub fn with_key_dispatch<R>(
         &mut self,
         context: Option<KeyContext>,
         }
     }
+    /// Register a callback that can interrupt the closing of the current window based the returned boolean.
+    /// If the callback returns false, the window won't be closed.
     pub fn on_window_should_close(&mut self, f: impl Fn(&mut WindowContext) -> bool + 'static) {
         let mut this = self.to_async();
         self.window
     }
 }
+/// This trait contains functionality that is shared across [`ViewContext`] and [`WindowContext`]
 pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
+    #[doc(hidden)]
     fn app_mut(&mut self) -> &mut AppContext {
         self.borrow_mut()
     }
+    #[doc(hidden)]
     fn app(&self) -> &AppContext {
         self.borrow()
     }
+    #[doc(hidden)]
     fn window(&self) -> &Window {
         self.borrow()
     }
+    #[doc(hidden)]
     fn window_mut(&mut self) -> &mut Window {
         self.borrow_mut()
     }
 impl<T> BorrowWindow for T where T: BorrowMut<AppContext> + BorrowMut<Window> {}
+/// Provides access to application state that is specialized for a particular [`View`].
+/// Allows you to interact with focus, emit events, etc.
+/// ViewContext also derefs to [`WindowContext`], giving you access to all of its methods as well.
+/// When you call [`View::update`], you're passed a `&mut V` and an `&mut ViewContext<V>`.
 pub struct ViewContext<'a, V> {
     window_cx: WindowContext<'a>,
     view: &'a View<V>,
         }
     }
+    /// Get the entity_id of this view.
     pub fn entity_id(&self) -> EntityId {
         self.view.entity_id()
     }
+    /// Get the view pointer underlying this context.
     pub fn view(&self) -> &View<V> {
         self.view
     }
+    /// Get the model underlying this view.
     pub fn model(&self) -> &Model<V> {
         &self.view.model
     }
         &mut self.window_cx
     }
+    /// Set a given callback to be run on the next frame.
     pub fn on_next_frame(&mut self, f: impl FnOnce(&mut V, &mut ViewContext<V>) + 'static)
     where
         V: 'static,
         });
     }
+    /// Observe another model or view for changes to its state, as tracked by [`ModelContext::notify`].
     pub fn observe<V2, E>(
         &mut self,
         entity: &E,
         subscription
     }
+    /// Subscribe to events emitted by another model or view.
+    /// The entity to which you're subscribing must implement the [`EventEmitter`] trait.
+    /// The callback will be invoked with a reference to the current view, a handle to the emitting entity (either a [`View`] or [`Model`]), the event, and a view context for the current view.
     pub fn subscribe<V2, E, Evt>(
         &mut self,
         entity: &E,
         subscription
     }
+    /// Register a callback to be invoked when the given Model or View is released.
     pub fn observe_release<V2, E>(
         &mut self,
         entity: &E,
         subscription
     }
+    /// Indicate that this view has changed, which will invoke any observers and also mark the window as dirty.
+    /// If this view or any of its ancestors are *cached*, notifying it will cause it or its ancestors to be redrawn.
     pub fn notify(&mut self) {
         if !self.window.drawing {
             self.window_cx.notify();
         }
     }
+    /// Register a callback to be invoked when the window is resized.
     pub fn observe_window_bounds(
         &mut self,
         mut callback: impl FnMut(&mut V, &mut ViewContext<V>) + 'static,
         subscription
     }
+    /// Register a callback to be invoked when the window is activated or deactivated.
     pub fn observe_window_activation(
         &mut self,
         mut callback: impl FnMut(&mut V, &mut ViewContext<V>) + 'static,
         subscription
     }
+    /// Schedule a future to be run asynchronously.
+    /// The given callback is invoked with a [`WeakView<V>`] to avoid leaking the view for a long-running process.
+    /// It's also given an [`AsyncWindowContext`], which can be used to access the state of the view across await points.
+    /// The returned future will be polled on the main thread.
     pub fn spawn<Fut, R>(
         &mut self,
         f: impl FnOnce(WeakView<V>, AsyncWindowContext) -> Fut,
         self.window_cx.spawn(|cx| f(view, cx))
     }
+    /// Update the global state of the given type.
     pub fn update_global<G, R>(&mut self, f: impl FnOnce(&mut G, &mut Self) -> R) -> R
     where
         G: 'static,
         result
     }
+    /// Register a callback to be invoked when the given global state changes.
     pub fn observe_global<G: 'static>(
         &mut self,
         mut f: impl FnMut(&mut V, &mut ViewContext<'_, V>) + 'static,
         subscription
     }
+    /// Add a listener for any mouse event that occurs in the window.
+    /// This is a fairly low level method.
+    /// Typically, you'll want to use methods on UI elements, which perform bounds checking etc.
     pub fn on_mouse_event<Event: 'static>(
         &mut self,
         handler: impl Fn(&mut V, &Event, DispatchPhase, &mut ViewContext<V>) + 'static,
         });
     }
+    /// Register a callback to be invoked when the given Key Event is dispatched to the window.
     pub fn on_key_event<Event: 'static>(
         &mut self,
         handler: impl Fn(&mut V, &Event, DispatchPhase, &mut ViewContext<V>) + 'static,
         });
     }
+    /// Register a callback to be invoked when the given Action type is dispatched to the window.
     pub fn on_action(
         &mut self,
         action_type: TypeId,
             });
     }
+    /// Emit an event to be handled any other views that have subscribed via [ViewContext::subscribe].
     pub fn emit<Evt>(&mut self, event: Evt)
     where
         Evt: 'static,
         });
     }
+    /// Move focus to the current view, assuming it implements [`FocusableView`].
     pub fn focus_self(&mut self)
     where
         V: FocusableView,
         self.defer(|view, cx| view.focus_handle(cx).focus(cx))
     }
+    /// Convenience method for accessing view state in an event callback.
+    ///
+    /// Many GPUI callbacks take the form of `Fn(&E, &mut WindowContext)`,
+    /// but it's often useful to be able to access view state in these
+    /// callbacks. This method provides a convenient way to do so.
     pub fn listener<E>(
         &self,
         f: impl Fn(&mut V, &E, &mut ViewContext<V>) + 'static,
 }
 // #[derive(Clone, Copy, Eq, PartialEq, Hash)]
-slotmap::new_key_type! { pub struct WindowId; }
+slotmap::new_key_type! {
+    /// A unique identifier for a window.
+    pub struct WindowId;
+}
 impl WindowId {
+    /// Converts this window ID to a `u64`.
     pub fn as_u64(&self) -> u64 {
         self.0.as_ffi()
     }
 }
+/// A handle to a window with a specific root view type.
+/// Note that this does not keep the window alive on its own.
 #[derive(Deref, DerefMut)]
 pub struct WindowHandle<V> {
     #[deref]
 }
 impl<V: 'static + Render> WindowHandle<V> {
+    /// Create a new handle from a window ID.
+    /// This does not check if the root type of the window is `V`.
     pub fn new(id: WindowId) -> Self {
         WindowHandle {
             any_handle: AnyWindowHandle {
         }
     }
+    /// Get the root view out of this window.
+    ///
+    /// This will fail if the window is closed or if the root view's type does not match `V`.
     pub fn root<C>(&self, cx: &mut C) -> Result<View<V>>
     where
         C: Context,
         }))
     }
+    /// Update the root view of this window.
+    ///
+    /// This will fail if the window has been closed or if the root view's type does not match
     pub fn update<C, R>(
         &self,
         cx: &mut C,
         })?
     }
+    /// Read the root view out of this window.
+    ///
+    /// This will fail if the window is closed or if the root view's type does not match `V`.
     pub fn read<'a>(&self, cx: &'a AppContext) -> Result<&'a V> {
         let x = cx
             .windows
         Ok(x.read(cx))
     }
+    /// Read the root view out of this window, with a callback
+    ///
+    /// This will fail if the window is closed or if the root view's type does not match `V`.
     pub fn read_with<C, R>(&self, cx: &C, read_with: impl FnOnce(&V, &AppContext) -> R) -> Result<R>
     where
         C: Context,
         cx.read_window(self, |root_view, cx| read_with(root_view.read(cx), cx))
     }
+    /// Read the root view pointer off of this window.
+    ///
+    /// This will fail if the window is closed or if the root view's type does not match `V`.
     pub fn root_view<C>(&self, cx: &C) -> Result<View<V>>
     where
         C: Context,
         cx.read_window(self, |root_view, _cx| root_view.clone())
     }
+    /// Check if this window is 'active'.
+    ///
+    /// Will return `None` if the window is closed.
     pub fn is_active(&self, cx: &AppContext) -> Option<bool> {
         cx.windows
             .get(self.id)
     }
 }
+/// A handle to a window with any root view type, which can be downcast to a window with a specific root view type.
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct AnyWindowHandle {
     pub(crate) id: WindowId,
 }
 impl AnyWindowHandle {
+    /// Get the ID of this window.
     pub fn window_id(&self) -> WindowId {
         self.id
     }
+    /// Attempt to convert this handle to a window handle with a specific root view type.
+    /// If the types do not match, this will return `None`.
     pub fn downcast<T: 'static>(&self) -> Option<WindowHandle<T>> {
         if TypeId::of::<T>() == self.state_type {
             Some(WindowHandle {
         }
     }
+    /// Update the state of the root view of this window.
+    ///
+    /// This will fail if the window has been closed.
     pub fn update<C, R>(
         self,
         cx: &mut C,
         cx.update_window(self, update)
     }
+    /// Read the state of the root view of this window.
+    ///
+    /// This will fail if the window has been closed.
     pub fn read<T, C, R>(self, cx: &C, read: impl FnOnce(View<T>, &AppContext) -> R) -> Result<R>
     where
         C: Context,
 //     }
 // }
+/// An identifier for an [`Element`](crate::Element).
+///
+/// Can be constructed with a string, a number, or both, as well
+/// as other internal representations.
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub enum ElementId {
+    /// The ID of a View element
     View(EntityId),
+    /// An integer ID.
     Integer(usize),
+    /// A string based ID.
     Name(SharedString),
+    /// An ID that's equated with a focus handle.
     FocusHandle(FocusId),
+    /// A combination of a name and an integer.
     NamedInteger(SharedString, usize),
 }
     }
 }
-/// A rectangle, to be rendered on the screen by GPUI at the given position and size.
+/// A rectangle to be rendered in the window at the given position and size.
+/// Passed as an argument [`WindowContext::paint_quad`].
 #[derive(Clone)]
 pub struct PaintQuad {
     bounds: Bounds<Pixels>,

crates/gpui/tests/action_macros.rs+6−6

@@ -18,33 +18,33 @@ fn test_action_macros() { · 17 unmodified lines
18		18
19	impl gpui::Action for RegisterableAction {	19	impl gpui::Action for RegisterableAction {
20	fn boxed_clone(&self) -> Box<dyn gpui::Action> {	20	fn boxed_clone(&self) -> Box<dyn gpui::Action> {
21	todo!()	21	unimplemented!()
22	}	22	}
23		23
24	fn as_any(&self) -> &dyn std::any::Any {	24	fn as_any(&self) -> &dyn std::any::Any {
25	todo!()	25	unimplemented!()
26	}	26	}
27		27
28	fn partial_eq(&self, _action: &dyn gpui::Action) -> bool {	28	fn partial_eq(&self, _action: &dyn gpui::Action) -> bool {
29	todo!()	29	unimplemented!()
30	}	30	}
31		31
32	fn name(&self) -> &str {	32	fn name(&self) -> &str {
33	todo!()	33	unimplemented!()
34	}	34	}
35		35
36	fn debug_name() -> &'static str	36	fn debug_name() -> &'static str
37	where	37	where
38	Self: Sized,	38	Self: Sized,
39	{	39	{
40	todo!()	40	unimplemented!()
41	}	41	}
42		42
43	fn build(_value: serde_json::Value) -> anyhow::Result<Box<dyn gpui::Action>>	43	fn build(_value: serde_json::Value) -> anyhow::Result<Box<dyn gpui::Action>>
44	where	44	where
45	Self: Sized,	45	Self: Sized,
46	{	46	{
47	todo!()	47	unimplemented!()
48	}	48	}
49	}	49	}
50	}	50	}

crates/gpui_macros/src/gpui_macros.rs+30−0

@@ -7,26 +7,56 @@ mod test; · 6 unmodified lines
7	use proc_macro::TokenStream;	7	use proc_macro::TokenStream;
8		8
9	#[proc_macro]	9	#[proc_macro]
		10	/// register_action! can be used to register an action with the GPUI runtime.
		11	/// You should typically use `gpui::actions!` or `gpui::impl_actions!` instead,
		12	/// but this can be used for fine grained customization.
10	pub fn register_action(ident: TokenStream) -> TokenStream {	13	pub fn register_action(ident: TokenStream) -> TokenStream {
11	register_action::register_action_macro(ident)	14	register_action::register_action_macro(ident)
12	}	15	}
13		16
14	#[proc_macro_derive(IntoElement)]	17	#[proc_macro_derive(IntoElement)]
		18	// #[derive(IntoElement)] is used to create a Component out of anything that implements
		19	// the `RenderOnce` trait.
15	pub fn derive_into_element(input: TokenStream) -> TokenStream {	20	pub fn derive_into_element(input: TokenStream) -> TokenStream {
16	derive_into_element::derive_into_element(input)	21	derive_into_element::derive_into_element(input)
17	}	22	}
18		23
19	#[proc_macro_derive(Render)]	24	#[proc_macro_derive(Render)]
		25	#[doc(hidden)]
20	pub fn derive_render(input: TokenStream) -> TokenStream {	26	pub fn derive_render(input: TokenStream) -> TokenStream {
21	derive_render::derive_render(input)	27	derive_render::derive_render(input)
22	}	28	}
23		29
		30	// Used by gpui to generate the style helpers.
24	#[proc_macro]	31	#[proc_macro]
		32	#[doc(hidden)]
25	pub fn style_helpers(input: TokenStream) -> TokenStream {	33	pub fn style_helpers(input: TokenStream) -> TokenStream {
26	style_helpers::style_helpers(input)	34	style_helpers::style_helpers(input)
27	}	35	}
28		36
29	#[proc_macro_attribute]	37	#[proc_macro_attribute]
		38	/// #[gpui::test] can be used to annotate test functions that run with GPUI support.
		39	/// it supports both synchronous and asynchronous tests, and can provide you with
		40	/// as many `TestAppContext` instances as you need.
		41	/// The output contains a `#[test]` annotation so this can be used with any existing
		42	/// test harness (`cargo test` or `cargo-nextest`).
		43	///
		44	/// ```
		45	/// #[gpui::test]
		46	/// async fn test_foo(mut cx: &TestAppContext) { }
		47	/// ```
		48	///
		49	/// In addition to passing a TestAppContext, you can also ask for a `StdRnd` instance.
		50	/// this will be seeded with the `SEED` environment variable and is used internally by
		51	/// the ForegroundExecutor and BackgroundExecutor to run tasks deterministically in tests.
		52	/// Using the same `StdRng` for behaviour in your test will allow you to exercise a wide
		53	/// variety of scenarios and interleavings just by changing the seed.
		54	///
		55	/// #[gpui::test] also takes three different arguments:
		56	/// - `#[gpui::test(interations=10)]` will run the test ten times with a different initial SEED.
		57	/// - `#[gpui::test(retries=3)]` will run the test up to four times if it fails to try and make it pass.
		58	/// - `#[gpui::test(on_failure="crate::test::report_failure")]` will call the specified function after the
		59	/// tests fail so that you can write out more detail about the failure.
30	pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {	60	pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
31	test::test(args, function)	61	test::test(args, function)
32	}	62	}

crates/language/src/syntax_map/syntax_map_tests.rs+14−14

@@ -258,19 +258,19 @@ fn test_typing_multiple_new_injections() { · 257 unmodified lines
258	let (buffer, syntax_map) = test_edit_sequence(	258	let (buffer, syntax_map) = test_edit_sequence(
259	"Rust",	259	"Rust",
260	&[	260	&[
261	"fn a() { dbg }",	261	"fn a() { test_macro }",
262	"fn a() { dbg«!» }",	262	"fn a() { test_macro«!» }",
263	"fn a() { dbg!«()» }",	263	"fn a() { test_macro!«()» }",
264	"fn a() { dbg!(«b») }",	264	"fn a() { test_macro!(«b») }",
265	"fn a() { dbg!(b«.») }",	265	"fn a() { test_macro!(b«.») }",
266	"fn a() { dbg!(b.«c») }",	266	"fn a() { test_macro!(b.«c») }",
267	"fn a() { dbg!(b.c«()») }",	267	"fn a() { test_macro!(b.c«()») }",
268	"fn a() { dbg!(b.c(«vec»)) }",	268	"fn a() { test_macro!(b.c(«vec»)) }",
269	"fn a() { dbg!(b.c(vec«!»)) }",	269	"fn a() { test_macro!(b.c(vec«!»)) }",
270	"fn a() { dbg!(b.c(vec!«[]»)) }",	270	"fn a() { test_macro!(b.c(vec!«[]»)) }",
271	"fn a() { dbg!(b.c(vec![«d»])) }",	271	"fn a() { test_macro!(b.c(vec![«d»])) }",
272	"fn a() { dbg!(b.c(vec![d«.»])) }",	272	"fn a() { test_macro!(b.c(vec![d«.»])) }",
273	"fn a() { dbg!(b.c(vec![d.«e»])) }",	273	"fn a() { test_macro!(b.c(vec![d.«e»])) }",
274	],	274	],
275	);	275	);
276		276
@@ -278,7 +278,7 @@ fn test_typing_multiple_new_injections() { · 1 unmodified line
278	&syntax_map,	278	&syntax_map,
279	&buffer,	279	&buffer,
280	&["field"],	280	&["field"],
281	"fn a() { dbg!(b.«c»(vec![d.«e»])) }",	281	"fn a() { test_macro!(b.«c»(vec![d.«e»])) }",
282	);	282	);
283	}	283	}
284		284

crates/project_panel/src/project_panel.rs+8−5

     sync::Arc,
 };
 use theme::ThemeSettings;
-use ui::{prelude::*, v_stack, ContextMenu, IconElement, KeyBinding, Label, ListItem};
+use ui::{prelude::*, v_stack, ContextMenu, Icon, KeyBinding, Label, ListItem};
 use unicase::UniCase;
 use util::{maybe, ResultExt, TryFutureExt};
 use workspace::{
                     .indent_step_size(px(settings.indent_size))
                     .selected(is_selected)
                     .child(if let Some(icon) = &icon {
-                        div().child(IconElement::from_path(icon.to_string()).color(Color::Muted))
+                        div().child(Icon::from_path(icon.to_string()).color(Color::Muted))
                     } else {
                         div().size(IconSize::default().rems()).invisible()
                     })
                     }))
                     .on_secondary_mouse_down(cx.listener(
                         move |this, event: &MouseDownEvent, cx| {
+                            // Stop propagation to prevent the catch-all context menu for the project
+                            // panel from being deployed.
+                            cx.stop_propagation();
                             this.deploy_context_menu(event.position, entry_id, cx);
                         },
                     )),
                     .indent_level(self.details.depth)
                     .indent_step_size(px(settings.indent_size))
                     .child(if let Some(icon) = &self.details.icon {
-                        div().child(IconElement::from_path(icon.to_string()))
+                        div().child(Icon::from_path(icon.to_string()))
                     } else {
                         div()
                     })
         cx.notify();
     }
-    fn icon(&self, _: &WindowContext) -> Option<ui::Icon> {
+    fn icon(&self, _: &WindowContext) -> Option<ui::IconName> {
-        Some(ui::Icon::FileTree)
+        Some(ui::IconName::FileTree)
     }
     fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {

crates/quick_action_bar/src/quick_action_bar.rs+6−6

@@ -6,7 +6,7 @@ use gpui::{ · 5 unmodified lines
6	Subscription, View, ViewContext, WeakView,	6	Subscription, View, ViewContext, WeakView,
7	};	7	};
8	use search::{buffer_search, BufferSearchBar};	8	use search::{buffer_search, BufferSearchBar};
9	use ui::{prelude::*, ButtonSize, ButtonStyle, Icon, IconButton, IconSize, Tooltip};	9	use ui::{prelude::*, ButtonSize, ButtonStyle, IconButton, IconName, IconSize, Tooltip};
10	use workspace::{	10	use workspace::{
11	item::ItemHandle, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,	11	item::ItemHandle, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
12	};	12	};
@@ -43,7 +43,7 @@ impl Render for QuickActionBar { · 30 unmodified lines
43		43
44	let inlay_hints_button = Some(QuickActionBarButton::new(	44	let inlay_hints_button = Some(QuickActionBarButton::new(
45	"toggle inlay hints",	45	"toggle inlay hints",
46	Icon::InlayHint,	46	IconName::InlayHint,
47	editor.read(cx).inlay_hints_enabled(),	47	editor.read(cx).inlay_hints_enabled(),
48	Box::new(editor::ToggleInlayHints),	48	Box::new(editor::ToggleInlayHints),
49	"Toggle Inlay Hints",	49	"Toggle Inlay Hints",
@@ -60,7 +60,7 @@ impl Render for QuickActionBar { · 10 unmodified lines
60		60
61	let search_button = Some(QuickActionBarButton::new(	61	let search_button = Some(QuickActionBarButton::new(
62	"toggle buffer search",	62	"toggle buffer search",
63	Icon::MagnifyingGlass,	63	IconName::MagnifyingGlass,
64	!self.buffer_search_bar.read(cx).is_dismissed(),	64	!self.buffer_search_bar.read(cx).is_dismissed(),
65	Box::new(buffer_search::Deploy { focus: false }),	65	Box::new(buffer_search::Deploy { focus: false }),
66	"Buffer Search",	66	"Buffer Search",
@@ -77,7 +77,7 @@ impl Render for QuickActionBar { · 10 unmodified lines
77		77
78	let assistant_button = QuickActionBarButton::new(	78	let assistant_button = QuickActionBarButton::new(
79	"toggle inline assistant",	79	"toggle inline assistant",
80	Icon::MagicWand,	80	IconName::MagicWand,
81	false,	81	false,
82	Box::new(InlineAssist),	82	Box::new(InlineAssist),
83	"Inline Assist",	83	"Inline Assist",
@@ -107,7 +107,7 @@ impl EventEmitter<ToolbarItemEvent> for QuickActionBar {} · 23 unmodified lines
107	#[derive(IntoElement)]	107	#[derive(IntoElement)]
108	struct QuickActionBarButton {	108	struct QuickActionBarButton {
109	id: ElementId,	109	id: ElementId,
110	icon: Icon,	110	icon: IconName,
111	toggled: bool,	111	toggled: bool,
112	action: Box<dyn Action>,	112	action: Box<dyn Action>,
113	tooltip: SharedString,	113	tooltip: SharedString,
@@ -117,7 +117,7 @@ struct QuickActionBarButton { · 3 unmodified lines
117	impl QuickActionBarButton {	117	impl QuickActionBarButton {
118	fn new(	118	fn new(
119	id: impl Into<ElementId>,	119	id: impl Into<ElementId>,
120	icon: Icon,	120	icon: IconName,
121	toggled: bool,	121	toggled: bool,
122	action: Box<dyn Action>,	122	action: Box<dyn Action>,
123	tooltip: impl Into<SharedString>,	123	tooltip: impl Into<SharedString>,

crates/rope/src/rope.rs+3−3

@@ -25,10 +25,10 @@ const CHUNK_BASE: usize = 6; · 24 unmodified lines
25	#[cfg(not(test))]	25	#[cfg(not(test))]
26	const CHUNK_BASE: usize = 16;	26	const CHUNK_BASE: usize = 16;
27		27
28	/// Type alias to [HashMatrix], an implementation of a homomorphic hash function. Two [Rope] instances	28	/// Type alias to [`HashMatrix`], an implementation of a homomorphic hash function. Two [`Rope`] instances
29	/// containing the same text will produce the same fingerprint. This hash function is special in that	29	/// containing the same text will produce the same fingerprint. This hash function is special in that
30	/// it allows us to hash individual chunks and aggregate them up the [Rope]'s tree, with the resulting	30	/// it allows us to hash individual chunks and aggregate them up the [`Rope`]'s tree, with the resulting
31	/// hash being equivalent to hashing all the text contained in the [Rope] at once.	31	/// hash being equivalent to hashing all the text contained in the [`Rope`] at once.
32	pub type RopeFingerprint = HashMatrix;	32	pub type RopeFingerprint = HashMatrix;
33		33
34	#[derive(Clone, Default)]	34	#[derive(Clone, Default)]

crates/rpc/src/notification.rs+30−25

@@ -76,30 +76,35 @@ impl Notification { · 75 unmodified lines
76	}	76	}
77	}	77	}
78		78
79	#[test]	79	#[cfg(test)]
80	fn test_notification() {	80	mod tests {
81	// Notifications can be serialized and deserialized.	81	use crate::Notification;
82	for notification in [	82
83	Notification::ContactRequest { sender_id: 1 },	83	#[test]
84	Notification::ContactRequestAccepted { responder_id: 2 },	84	fn test_notification() {
85	Notification::ChannelInvitation {	85	// Notifications can be serialized and deserialized.
86	channel_id: 100,	86	for notification in [
87	channel_name: "the-channel".into(),	87	Notification::ContactRequest { sender_id: 1 },
88	inviter_id: 50,	88	Notification::ContactRequestAccepted { responder_id: 2 },
89	},	89	Notification::ChannelInvitation {
90	Notification::ChannelMessageMention {	90	channel_id: 100,
91	sender_id: 200,	91	channel_name: "the-channel".into(),
92	channel_id: 30,	92	inviter_id: 50,
93	message_id: 1,	93	},
94	},	94	Notification::ChannelMessageMention {
95	] {	95	sender_id: 200,
96	let message = notification.to_proto();	96	channel_id: 30,
97	let deserialized = Notification::from_proto(&message).unwrap();	97	message_id: 1,
98	assert_eq!(deserialized, notification);	98	},
99	}	99	] {
		100	let message = notification.to_proto();
		101	let deserialized = Notification::from_proto(&message).unwrap();
		102	assert_eq!(deserialized, notification);
		103	}
100		104
101	// When notifications are serialized, the `kind` and `actor_id` fields are	105	// When notifications are serialized, the `kind` and `actor_id` fields are
102	// stored separately, and do not appear redundantly in the JSON.	106	// stored separately, and do not appear redundantly in the JSON.
103	let notification = Notification::ContactRequest { sender_id: 1 };	107	let notification = Notification::ContactRequest { sender_id: 1 };
104	assert_eq!(notification.to_proto().content, "{}");	108	assert_eq!(notification.to_proto().content, "{}");
		109	}
105	}	110	}

crates/search/src/buffer_search.rs+17−12

 use std::{any::Any, sync::Arc};
 use theme::ThemeSettings;
-use ui::{h_stack, prelude::*, Icon, IconButton, IconElement, ToggleButton, Tooltip};
+use ui::{h_stack, prelude::*, Icon, IconButton, IconName, ToggleButton, Tooltip};
 use util::ResultExt;
 use workspace::{
     item::ItemHandle,
 }
 pub fn init(cx: &mut AppContext) {
-    cx.observe_new_views(|editor: &mut Workspace, _| BufferSearchBar::register(editor))
+    cx.observe_new_views(|workspace: &mut Workspace, _| BufferSearchBar::register(workspace))
         .detach();
 }
                     .border_color(editor_border)
                     .min_w(rems(384. / 16.))
                     .rounded_lg()
-                    .child(IconElement::new(Icon::MagnifyingGlass))
+                    .child(Icon::new(IconName::MagnifyingGlass))
                     .child(self.render_text_input(&self.query_editor, cx))
                     .children(supported_options.case.then(|| {
                         self.render_search_option_button(
                         this.child(
                             IconButton::new(
                                 "buffer-search-bar-toggle-replace-button",
-                                Icon::Replace,
+                                IconName::Replace,
                             )
                             .style(ButtonStyle::Subtle)
                             .when(self.replace_enabled, |button| {
                         )
                         .when(should_show_replace_input, |this| {
                             this.child(
-                                IconButton::new("search-replace-next", ui::Icon::ReplaceNext)
+                                IconButton::new("search-replace-next", ui::IconName::ReplaceNext)
                                     .tooltip(move |cx| {
                                         Tooltip::for_action("Replace next", &ReplaceNext, cx)
                                     })
                                     })),
                             )
                             .child(
-                                IconButton::new("search-replace-all", ui::Icon::ReplaceAll)
+                                IconButton::new("search-replace-all", ui::IconName::ReplaceAll)
                                     .tooltip(move |cx| {
                                         Tooltip::for_action("Replace all", &ReplaceAll, cx)
                                     })
                     .gap_0p5()
                     .flex_none()
                     .child(
-                        IconButton::new("select-all", ui::Icon::SelectAll)
+                        IconButton::new("select-all", ui::IconName::SelectAll)
                             .on_click(|_, cx| cx.dispatch_action(SelectAllMatches.boxed_clone()))
                             .tooltip(|cx| {
                                 Tooltip::for_action("Select all matches", &SelectAllMatches, cx)
                     )
                     .children(match_count)
                     .child(render_nav_button(
-                        ui::Icon::ChevronLeft,
+                        ui::IconName::ChevronLeft,
                         self.active_match_index.is_some(),
                         "Select previous match",
                         &SelectPrevMatch,
                     ))
                     .child(render_nav_button(
-                        ui::Icon::ChevronRight,
+                        ui::IconName::ChevronRight,
                         self.active_match_index.is_some(),
                         "Select next match",
                         &SelectNextMatch,
         callback: fn(&mut BufferSearchBar, &A, &mut ViewContext<BufferSearchBar>),
     ) {
         self.register_action(move |workspace, action: &A, cx| {
+            if workspace.has_active_modal(cx) {
+                cx.propagate();
+                return;
+            }
             let pane = workspace.active_pane();
             pane.update(cx, move |this, cx| {
                 this.toolbar().update(cx, move |this, cx| {
             this.select_all_matches(action, cx);
         });
         registrar.register_handler(|this, _: &editor::Cancel, cx| {
-            if !this.dismissed {
+            if this.dismissed {
+                cx.propagate();
+            } else {
                 this.dismiss(&Dismiss, cx);
-                return;
             }
-            cx.propagate();
         });
         registrar.register_handler(|this, deploy, cx| {
             this.deploy(deploy, cx);

crates/search/src/project_search.rs+14−13

 use theme::ThemeSettings;
 use ui::{
-    h_stack, prelude::*, v_stack, Icon, IconButton, IconElement, Label, LabelCommon, LabelSize,
+    h_stack, prelude::*, v_stack, Icon, IconButton, IconName, Label, LabelCommon, LabelSize,
     Selectable, ToggleButton, Tooltip,
 };
 use util::{paths::PathMatcher, ResultExt as _};
             .current()
             .as_ref()
             .map(|query| {
-                let query_text = util::truncate_and_trailoff(query, MAX_TAB_TITLE_LEN);
+                let query = query.replace('\n', "");
+                let query_text = util::truncate_and_trailoff(&query, MAX_TAB_TITLE_LEN);
                 query_text.into()
             });
         let tab_name = last_query
             .unwrap_or_else(|| "Project search".into());
         h_stack()
             .gap_2()
-            .child(IconElement::new(Icon::MagnifyingGlass).color(if selected {
+            .child(Icon::new(IconName::MagnifyingGlass).color(if selected {
                 Color::Default
             } else {
                 Color::Muted
                 .on_action(cx.listener(|this, action, cx| this.confirm(action, cx)))
                 .on_action(cx.listener(|this, action, cx| this.previous_history_query(action, cx)))
                 .on_action(cx.listener(|this, action, cx| this.next_history_query(action, cx)))
-                .child(IconElement::new(Icon::MagnifyingGlass))
+                .child(Icon::new(IconName::MagnifyingGlass))
                 .child(self.render_text_input(&search.query_editor, cx))
                 .child(
                     h_stack()
                         .child(
-                            IconButton::new("project-search-filter-button", Icon::Filter)
+                            IconButton::new("project-search-filter-button", IconName::Filter)
                                 .tooltip(|cx| {
                                     Tooltip::for_action("Toggle filters", &ToggleFilters, cx)
                                 })
                             this.child(
                                 IconButton::new(
                                     "project-search-case-sensitive",
-                                    Icon::CaseSensitive,
+                                    IconName::CaseSensitive,
                                 )
                                 .tooltip(|cx| {
                                     Tooltip::for_action(
                                 )),
                             )
                             .child(
-                                IconButton::new("project-search-whole-word", Icon::WholeWord)
+                                IconButton::new("project-search-whole-word", IconName::WholeWord)
                                     .tooltip(|cx| {
                                         Tooltip::for_action(
                                             "Toggle whole word",
                         }),
                 )
                 .child(
-                    IconButton::new("project-search-toggle-replace", Icon::Replace)
+                    IconButton::new("project-search-toggle-replace", IconName::Replace)
                         .on_click(cx.listener(|this, _, cx| {
                             this.toggle_replace(&ToggleReplace, cx);
                         }))
                 .border_1()
                 .border_color(cx.theme().colors().border)
                 .rounded_lg()
-                .child(IconElement::new(Icon::Replace).size(ui::IconSize::Small))
+                .child(Icon::new(IconName::Replace).size(ui::IconSize::Small))
                 .child(self.render_text_input(&search.replacement_editor, cx))
         } else {
             // Fill out the space if we don't have a replacement editor.
         let actions_column = h_stack()
             .when(search.replace_enabled, |this| {
                 this.child(
-                    IconButton::new("project-search-replace-next", Icon::ReplaceNext)
+                    IconButton::new("project-search-replace-next", IconName::ReplaceNext)
                         .on_click(cx.listener(|this, _, cx| {
                             if let Some(search) = this.active_project_search.as_ref() {
                                 search.update(cx, |this, cx| {
                         .tooltip(|cx| Tooltip::for_action("Replace next match", &ReplaceNext, cx)),
                 )
                 .child(
-                    IconButton::new("project-search-replace-all", Icon::ReplaceAll)
+                    IconButton::new("project-search-replace-all", IconName::ReplaceAll)
                         .on_click(cx.listener(|this, _, cx| {
                             if let Some(search) = this.active_project_search.as_ref() {
                                 search.update(cx, |this, cx| {
                 this
             })
             .child(
-                IconButton::new("project-search-prev-match", Icon::ChevronLeft)
+                IconButton::new("project-search-prev-match", IconName::ChevronLeft)
                     .disabled(search.active_match_index.is_none())
                     .on_click(cx.listener(|this, _, cx| {
                         if let Some(search) = this.active_project_search.as_ref() {
                     }),
             )
             .child(
-                IconButton::new("project-search-next-match", Icon::ChevronRight)
+                IconButton::new("project-search-next-match", IconName::ChevronRight)
                     .disabled(search.active_match_index.is_none())
                     .on_click(cx.listener(|this, _, cx| {
                         if let Some(search) = this.active_project_search.as_ref() {

crates/search/src/search.rs+4−4

@@ -60,11 +60,11 @@ impl SearchOptions { · 59 unmodified lines
60	}	60	}
61	}	61	}
62		62
63	pub fn icon(&self) -> ui::Icon {	63	pub fn icon(&self) -> ui::IconName {
64	match *self {	64	match *self {
65	SearchOptions::WHOLE_WORD => ui::Icon::WholeWord,	65	SearchOptions::WHOLE_WORD => ui::IconName::WholeWord,
66	SearchOptions::CASE_SENSITIVE => ui::Icon::CaseSensitive,	66	SearchOptions::CASE_SENSITIVE => ui::IconName::CaseSensitive,
67	SearchOptions::INCLUDE_IGNORED => ui::Icon::FileGit,	67	SearchOptions::INCLUDE_IGNORED => ui::IconName::FileGit,
68	_ => panic!("{:?} is not a named SearchOption", self),	68	_ => panic!("{:?} is not a named SearchOption", self),
69	}	69	}
70	}	70	}

crates/search/src/search_bar.rs+1−1

@@ -3,7 +3,7 @@ use ui::IconButton; · 2 unmodified lines
3	use ui::{prelude::*, Tooltip};	3	use ui::{prelude::*, Tooltip};
4		4
5	pub(super) fn render_nav_button(	5	pub(super) fn render_nav_button(
6	icon: ui::Icon,	6	icon: ui::IconName,
7	active: bool,	7	active: bool,
8	tooltip: &'static str,	8	tooltip: &'static str,
9	action: &'static dyn Action,	9	action: &'static dyn Action,

crates/storybook/Cargo.toml+1−0

@@ -14,6 +14,7 @@ anyhow.workspace = true · 13 unmodified lines
14	backtrace-on-stack-overflow = "0.3.0"	14	backtrace-on-stack-overflow = "0.3.0"
15	chrono = "0.4"	15	chrono = "0.4"
16	clap = { version = "4.4", features = ["derive", "string"] }	16	clap = { version = "4.4", features = ["derive", "string"] }
		17	collab_ui = { path = "../collab_ui", features = ["stories"] }
17	strum = { version = "0.25.0", features = ["derive"] }	18	strum = { version = "0.25.0", features = ["derive"] }
18	dialoguer = { version = "0.11.0", features = ["fuzzy-select"] }	19	dialoguer = { version = "0.11.0", features = ["fuzzy-select"] }
19	editor = { path = "../editor" }	20	editor = { path = "../editor" }

crates/storybook/src/story_selector.rs+4−0

     Avatar,
     Button,
     Checkbox,
+    CollabNotification,
     ContextMenu,
     Cursor,
     Disclosure,
             Self::Avatar => cx.new_view(|_| ui::AvatarStory).into(),
             Self::Button => cx.new_view(|_| ui::ButtonStory).into(),
             Self::Checkbox => cx.new_view(|_| ui::CheckboxStory).into(),
+            Self::CollabNotification => cx
+                .new_view(|_| collab_ui::notifications::CollabNotificationStory)
+                .into(),
             Self::ContextMenu => cx.new_view(|_| ui::ContextMenuStory).into(),
             Self::Cursor => cx.new_view(|_| crate::stories::CursorStory).into(),
             Self::Disclosure => cx.new_view(|_| ui::DisclosureStory).into(),

crates/terminal_view/src/terminal_element.rs+12−0

@@ -451,6 +451,18 @@ impl TerminalElement { · 450 unmodified lines
451	}	451	}
452	});	452	});
453		453
		454	let interactive_text_bounds = InteractiveBounds {
		455	bounds,
		456	stacking_order: cx.stacking_order().clone(),
		457	};
		458	if interactive_text_bounds.visibly_contains(&cx.mouse_position(), cx) {
		459	if self.can_navigate_to_selected_word && last_hovered_word.is_some() {
		460	cx.set_cursor_style(gpui::CursorStyle::PointingHand)
		461	} else {
		462	cx.set_cursor_style(gpui::CursorStyle::IBeam)
		463	}
		464	}
		465
454	let hyperlink_tooltip = last_hovered_word.clone().map(\|hovered_word\| {	466	let hyperlink_tooltip = last_hovered_word.clone().map(\|hovered_word\| {
455	div()	467	div()
456	.size_full()	468	.size_full()

crates/terminal_view/src/terminal_panel.rs+6−6

@@ -19,7 +19,7 @@ use workspace::{ · 18 unmodified lines
19	dock::{DockPosition, Panel, PanelEvent},	19	dock::{DockPosition, Panel, PanelEvent},
20	item::Item,	20	item::Item,
21	pane,	21	pane,
22	ui::Icon,	22	ui::IconName,
23	DraggedTab, Pane, Workspace,	23	DraggedTab, Pane, Workspace,
24	};	24	};
25		25
@@ -71,7 +71,7 @@ impl TerminalPanel { · 45 unmodified lines
71	h_stack()	71	h_stack()
72	.gap_2()	72	.gap_2()
73	.child(	73	.child(
74	IconButton::new("plus", Icon::Plus)	74	IconButton::new("plus", IconName::Plus)
75	.icon_size(IconSize::Small)	75	.icon_size(IconSize::Small)
76	.on_click(move \|_, cx\| {	76	.on_click(move \|_, cx\| {
77	terminal_panel	77	terminal_panel
@@ -82,10 +82,10 @@ impl TerminalPanel { · 4 unmodified lines
82	)	82	)
83	.child({	83	.child({
84	let zoomed = pane.is_zoomed();	84	let zoomed = pane.is_zoomed();
85	IconButton::new("toggle_zoom", Icon::Maximize)	85	IconButton::new("toggle_zoom", IconName::Maximize)
86	.icon_size(IconSize::Small)	86	.icon_size(IconSize::Small)
87	.selected(zoomed)	87	.selected(zoomed)
88	.selected_icon(Icon::Minimize)	88	.selected_icon(IconName::Minimize)
89	.on_click(cx.listener(\|pane, _, cx\| {	89	.on_click(cx.listener(\|pane, _, cx\| {
90	pane.toggle_zoom(&workspace::ToggleZoom, cx);	90	pane.toggle_zoom(&workspace::ToggleZoom, cx);
91	}))	91	}))
@@ -477,8 +477,8 @@ impl Panel for TerminalPanel { · 385 unmodified lines
477	"TerminalPanel"	477	"TerminalPanel"
478	}	478	}
479		479
480	fn icon(&self, _cx: &WindowContext) -> Option<Icon> {	480	fn icon(&self, _cx: &WindowContext) -> Option<IconName> {
481	Some(Icon::Terminal)	481	Some(IconName::Terminal)
482	}	482	}
483		483
484	fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {	484	fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {

crates/terminal_view/src/terminal_view.rs+2−2

@@ -20,7 +20,7 @@ use terminal::{ · 19 unmodified lines
20	Clear, Copy, Event, MaybeNavigationTarget, Paste, ShowCharacterPalette, Terminal,	20	Clear, Copy, Event, MaybeNavigationTarget, Paste, ShowCharacterPalette, Terminal,
21	};	21	};
22	use terminal_element::TerminalElement;	22	use terminal_element::TerminalElement;
23	use ui::{h_stack, prelude::*, ContextMenu, Icon, IconElement, Label};	23	use ui::{h_stack, prelude::*, ContextMenu, Icon, IconName, Label};
24	use util::{paths::PathLikeWithPosition, ResultExt};	24	use util::{paths::PathLikeWithPosition, ResultExt};
25	use workspace::{	25	use workspace::{
26	item::{BreadcrumbText, Item, ItemEvent},	26	item::{BreadcrumbText, Item, ItemEvent},
@@ -690,7 +690,7 @@ impl Item for TerminalView { · 663 unmodified lines
690	let title = self.terminal().read(cx).title(true);	690	let title = self.terminal().read(cx).title(true);
691	h_stack()	691	h_stack()
692	.gap_2()	692	.gap_2()
693	.child(IconElement::new(Icon::Terminal))	693	.child(Icon::new(IconName::Terminal))
694	.child(Label::new(title).color(if selected {	694	.child(Label::new(title).color(if selected {
695	Color::Default	695	Color::Default
696	} else {	696	} else {

crates/text/src/anchor.rs+1−1

@@ -90,7 +90,7 @@ impl Anchor { · 89 unmodified lines
90	content.summary_for_anchor(self)	90	content.summary_for_anchor(self)
91	}	91	}
92		92
93	/// Returns true when the [Anchor] is located inside a visible fragment.	93	/// Returns true when the [`Anchor`] is located inside a visible fragment.
94	pub fn is_valid(&self, buffer: &BufferSnapshot) -> bool {	94	pub fn is_valid(&self, buffer: &BufferSnapshot) -> bool {
95	if self == Anchor::MIN \|\| self == Anchor::MAX {	95	if self == Anchor::MIN \|\| self == Anchor::MAX {
96	true	96	true

crates/theme/src/scale.rs+8−1

 use crate::{ActiveTheme, Appearance};
-/// A one-based step in a [`ColorScale`].
+/// A collection of colors that are used to style the UI.
+///
+/// Each step has a semantic meaning, and is used to style different parts of the UI.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
 pub struct ColorScaleStep(usize);
     ];
 }
+/// A scale of colors for a given [`ColorScaleSet`].
+///
+/// Each [`ColorScale`] contains exactly 12 colors. Refer to
+/// [`ColorScaleStep`] for a reference of what each step is used for.
 pub struct ColorScale(Vec<Hsla>);
 impl FromIterator<Hsla> for ColorScale {
     }
 }
+/// Provides groups of [`ColorScale`]s for light and dark themes, as well as transparent versions of each scale.
 pub struct ColorScaleSet {
     name: SharedString,
     light: ColorScale,

crates/theme/src/settings.rs+1−1

@@ -27,7 +27,7 @@ pub struct ThemeSettings { · 26 unmodified lines
27	}	27	}
28		28
29	#[derive(Default)]	29	#[derive(Default)]
30	pub struct AdjustedBufferFontSize(Pixels);	30	pub(crate) struct AdjustedBufferFontSize(Pixels);
31		31
32	#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]	32	#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
33	pub struct ThemeSettingsContent {	33	pub struct ThemeSettingsContent {

crates/theme/src/styles/colors.rs+4−1

 use refineable::Refineable;
 use std::sync::Arc;
-use crate::{PlayerColors, StatusColors, SyntaxTheme, SystemColors};
+use crate::{PlayerColors, StatusColors, StatusColorsRefinement, SyntaxTheme, SystemColors};
 #[derive(Refineable, Clone, Debug)]
 #[refineable(Debug, serde::Deserialize)]
 pub struct ThemeColors {
+    /// Border color. Used for most borders, is usually a high contrast color.
     pub border: Hsla,
     /// Border color. Used for deemphasized borders, like a visual divider between two sections
     pub border_variant: Hsla,
     #[refineable]
     pub colors: ThemeColors,
+    #[refineable]
     pub status: StatusColors,
     pub player: PlayerColors,
     pub syntax: Arc<SyntaxTheme>,

crates/theme/src/styles/status.rs+0−9

@@ -78,15 +78,6 @@ pub struct StatusColors { · 77 unmodified lines
78	pub warning_border: Hsla,	78	pub warning_border: Hsla,
79	}	79	}
80		80
81	impl Default for StatusColors {
82	/// Don't use this!
83	/// We have to have a default to be `[refineable::Refinable]`.
84	/// todo!("Find a way to not need this for Refinable")
85	fn default() -> Self {
86	Self::dark()
87	}
88	}
89
90	pub struct DiagnosticColors {	81	pub struct DiagnosticColors {
91	pub error: Hsla,	82	pub error: Hsla,
92	pub warning: Hsla,	83	pub warning: Hsla,

crates/theme/src/theme.rs+8−0

@@ -1,3 +1,11 @@
		1	//! # Theme
		2	//!
		3	//! This crate provides the theme system for Zed.
		4	//!
		5	//! ## Overview
		6	//!
		7	//! A theme is a collection of colors used to build a consistent appearance for UI components across the application.
		8
1	mod default_colors;	9	mod default_colors;
2	mod default_theme;	10	mod default_theme;
3	mod one_themes;	11	mod one_themes;

crates/theme/theme.md+15−0

@@ -0,0 +1,15 @@
	1	# Theme
	2
	3	This crate provides the theme system for Zed.
	4
	5	## Overview
	6
	7	A theme is a collection of colors used to build a consistent appearance for UI components across the application.
	8	To produce a theme in Zed,
	9
	10	A theme is made of of two parts: A [ThemeFamily] and one or more [Theme]s.
	11
	12	//
	13	A [ThemeFamily] contains metadata like theme name, author, and theme-specific [ColorScales] as well as a series of themes.
	14
	15	- [ThemeColors] - A set of colors that are used to style the UI. Refer to the [ThemeColors] documentation for more information.

crates/ui/src/clickable.rs+1−1

@@ -1,6 +1,6 @@
1	use gpui::{ClickEvent, WindowContext};	1	use gpui::{ClickEvent, WindowContext};
2		2
3	/// A trait for elements that can be clicked.	3	/// A trait for elements that can be clicked. Enables the use of the `on_click` method.
4	pub trait Clickable {	4	pub trait Clickable {
5	/// Sets the click handler that will fire whenever the element is clicked.	5	/// Sets the click handler that will fire whenever the element is clicked.
6	fn on_click(self, handler: impl Fn(&ClickEvent, &mut WindowContext) + 'static) -> Self;	6	fn on_click(self, handler: impl Fn(&ClickEvent, &mut WindowContext) + 'static) -> Self;

crates/ui/src/components/avatar.rs+35−5

 use crate::prelude::*;
 use gpui::{img, Hsla, ImageSource, Img, IntoElement, Styled};
+/// The shape of an [`Avatar`].
 #[derive(Debug, Default, PartialEq, Clone)]
-pub enum Shape {
+pub enum AvatarShape {
+    /// The avatar is shown in a circle.
     #[default]
     Circle,
+    /// The avatar is shown in a rectangle with rounded corners.
     RoundedRectangle,
 }
+/// An element that renders a user avatar with customizable appearance options.
+///
+/// # Examples
+///
+/// ```
+/// Avatar::new("path/to/image.png")
+///     .shape(AvatarShape::Circle)
+///     .grayscale(true)
+///     .border_color(cx.theme().colors().border)
+/// ```
 #[derive(IntoElement)]
 pub struct Avatar {
     image: Img,
 impl RenderOnce for Avatar {
     fn render(mut self, cx: &mut WindowContext) -> impl IntoElement {
         if self.image.style().corner_radii.top_left.is_none() {
-            self = self.shape(Shape::Circle);
+            self = self.shape(AvatarShape::Circle);
         }
         let size = cx.rem_size();
         }
     }
-    pub fn shape(mut self, shape: Shape) -> Self {
+    /// Sets the shape of the avatar image.
+    ///
+    /// This method allows the shape of the avatar to be specified using a [`Shape`].
+    /// It modifies the corner radius of the image to match the specified shape.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// Avatar::new("path/to/image.png").shape(AvatarShape::Circle);
+    /// ```
+    pub fn shape(mut self, shape: AvatarShape) -> Self {
         self.image = match shape {
-            Shape::Circle => self.image.rounded_full(),
+            AvatarShape::Circle => self.image.rounded_full(),
-            Shape::RoundedRectangle => self.image.rounded_md(),
+            AvatarShape::RoundedRectangle => self.image.rounded_md(),
         };
         self
     }
+    /// Applies a grayscale filter to the avatar image.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let avatar = Avatar::new("path/to/image.png").grayscale(true);
+    /// ```
     pub fn grayscale(mut self, grayscale: bool) -> Self {
         self.image = self.image.grayscale(grayscale);
         self

crates/ui/src/components/button/button.rs+175−5

@@ -2,11 +2,69 @@ use gpui::{AnyView, DefiniteLength}; · 1 unmodified line
2		2
3	use crate::{prelude::*, IconPosition, KeyBinding};	3	use crate::{prelude::*, IconPosition, KeyBinding};
4	use crate::{	4	use crate::{
5	ButtonCommon, ButtonLike, ButtonSize, ButtonStyle, Icon, IconSize, Label, LineHeightStyle,	5	ButtonCommon, ButtonLike, ButtonSize, ButtonStyle, IconName, IconSize, Label, LineHeightStyle,
6	};	6	};
7		7
8	use super::button_icon::ButtonIcon;	8	use super::button_icon::ButtonIcon;
9		9
		10	/// An element that creates a button with a label and an optional icon.
		11	///
		12	/// Common buttons:
		13	/// - Label, Icon + Label: [`Button`] (this component)
		14	/// - Icon only: [`IconButton`]
		15	/// - Custom: [`ButtonLike`]
		16	///
		17	/// To create a more complex button than what the [`Button`] or [`IconButton`] components provide, use
		18	/// [`ButtonLike`] directly.
		19	///
		20	/// # Examples
		21	///
		22	/// A button with a label, is typically used in scenarios such as a form, where the button's label
		23	/// indicates what action will be performed when the button is clicked.
		24	///
		25	/// ```
		26	/// Button::new("button_id", "Click me!")
		27	/// .on_click(\|event, cx\| {
		28	/// // Handle click event
		29	/// });
		30	/// ```
		31	///
		32	/// A toggleable button, is typically used in scenarios such as a toolbar,
		33	/// where the button's state indicates whether a feature is enabled or not, or
		34	/// a trigger for a popover menu, where clicking the button toggles the visibility of the menu.
		35	///
		36	/// ```
		37	/// Button::new("button_id", "Click me!")
		38	/// .icon(IconName::Check)
		39	/// .selected(some_bool)
		40	/// .on_click(\|event, cx\| {
		41	/// // Handle click event
		42	/// });
		43	/// ```
		44	///
		45	/// To change the style of the button when it is selected use the [`selected_style`][Button::selected_style] method.
		46	///
		47	/// ```
		48	/// Button::new("button_id", "Click me!")
		49	/// .selected(some_bool)
		50	/// .selected_style(ButtonStyle::Tinted(TintColor::Accent))
		51	/// .on_click(\|event, cx\| {
		52	/// // Handle click event
		53	/// });
		54	/// ```
		55	/// This will create a button with a blue tinted background when selected.
		56	///
		57	/// A full-width button, is typically used in scenarios such as the bottom of a modal or form, where it occupies the entire width of its container.
		58	/// The button's content, including text and icons, is centered by default.
		59	///
		60	/// ```
		61	/// let button = Button::new("button_id", "Click me!")
		62	/// .full_width()
		63	/// .on_click(\|event, cx\| {
		64	/// // Handle click event
		65	/// });
		66	/// ```
		67	///
10	#[derive(IntoElement)]	68	#[derive(IntoElement)]
11	pub struct Button {	69	pub struct Button {
12	base: ButtonLike,	70	base: ButtonLike,
@@ -14,15 +72,21 @@ pub struct Button { · 1 unmodified line
14	label_color: Option<Color>,	72	label_color: Option<Color>,
15	label_size: Option<LabelSize>,	73	label_size: Option<LabelSize>,
16	selected_label: Option<SharedString>,	74	selected_label: Option<SharedString>,
17	icon: Option<Icon>,	75	icon: Option<IconName>,
18	icon_position: Option<IconPosition>,	76	icon_position: Option<IconPosition>,
19	icon_size: Option<IconSize>,	77	icon_size: Option<IconSize>,
20	icon_color: Option<Color>,	78	icon_color: Option<Color>,
21	selected_icon: Option<Icon>,	79	selected_icon: Option<IconName>,
22	key_binding: Option<KeyBinding>,	80	key_binding: Option<KeyBinding>,
23	}	81	}
24		82
25	impl Button {	83	impl Button {
		84	/// Creates a new [`Button`] with a specified identifier and label.
		85	///
		86	/// This is the primary constructor for a [`Button`] component. It initializes
		87	/// the button with the provided identifier and label text, setting all other
		88	/// properties to their default values, which can be customized using the
		89	/// builder pattern methods provided by this struct.
26	pub fn new(id: impl Into<ElementId>, label: impl Into<SharedString>) -> Self {	90	pub fn new(id: impl Into<ElementId>, label: impl Into<SharedString>) -> Self {
27	Self {	91	Self {
28	base: ButtonLike::new(id),	92	base: ButtonLike::new(id),
@@ -39,46 +103,55 @@ impl Button { · 10 unmodified lines
39	}	103	}
40	}	104	}
41		105
		106	/// Sets the color of the button's label.
42	pub fn color(mut self, label_color: impl Into<Option<Color>>) -> Self {	107	pub fn color(mut self, label_color: impl Into<Option<Color>>) -> Self {
43	self.label_color = label_color.into();	108	self.label_color = label_color.into();
44	self	109	self
45	}	110	}
46		111
		112	/// Defines the size of the button's label.
47	pub fn label_size(mut self, label_size: impl Into<Option<LabelSize>>) -> Self {	113	pub fn label_size(mut self, label_size: impl Into<Option<LabelSize>>) -> Self {
48	self.label_size = label_size.into();	114	self.label_size = label_size.into();
49	self	115	self
50	}	116	}
51		117
		118	/// Sets the label used when the button is in a selected state.
52	pub fn selected_label<L: Into<SharedString>>(mut self, label: impl Into<Option<L>>) -> Self {	119	pub fn selected_label<L: Into<SharedString>>(mut self, label: impl Into<Option<L>>) -> Self {
53	self.selected_label = label.into().map(Into::into);	120	self.selected_label = label.into().map(Into::into);
54	self	121	self
55	}	122	}
56		123
57	pub fn icon(mut self, icon: impl Into<Option<Icon>>) -> Self {	124	/// Assigns an icon to the button.
		125	pub fn icon(mut self, icon: impl Into<Option<IconName>>) -> Self {
58	self.icon = icon.into();	126	self.icon = icon.into();
59	self	127	self
60	}	128	}
61		129
		130	/// Sets the position of the icon relative to the label.
62	pub fn icon_position(mut self, icon_position: impl Into<Option<IconPosition>>) -> Self {	131	pub fn icon_position(mut self, icon_position: impl Into<Option<IconPosition>>) -> Self {
63	self.icon_position = icon_position.into();	132	self.icon_position = icon_position.into();
64	self	133	self
65	}	134	}
66		135
		136	/// Specifies the size of the button's icon.
67	pub fn icon_size(mut self, icon_size: impl Into<Option<IconSize>>) -> Self {	137	pub fn icon_size(mut self, icon_size: impl Into<Option<IconSize>>) -> Self {
68	self.icon_size = icon_size.into();	138	self.icon_size = icon_size.into();
69	self	139	self
70	}	140	}
71		141
		142	/// Sets the color of the button's icon.
72	pub fn icon_color(mut self, icon_color: impl Into<Option<Color>>) -> Self {	143	pub fn icon_color(mut self, icon_color: impl Into<Option<Color>>) -> Self {
73	self.icon_color = icon_color.into();	144	self.icon_color = icon_color.into();
74	self	145	self
75	}	146	}
76		147
77	pub fn selected_icon(mut self, icon: impl Into<Option<Icon>>) -> Self {	148	/// Chooses an icon to display when the button is in a selected state.
		149	pub fn selected_icon(mut self, icon: impl Into<Option<IconName>>) -> Self {
78	self.selected_icon = icon.into();	150	self.selected_icon = icon.into();
79	self	151	self
80	}	152	}
81		153
		154	/// Binds a key combination to the button for keyboard shortcuts.
82	pub fn key_binding(mut self, key_binding: impl Into<Option<KeyBinding>>) -> Self {	155	pub fn key_binding(mut self, key_binding: impl Into<Option<KeyBinding>>) -> Self {
83	self.key_binding = key_binding.into();	156	self.key_binding = key_binding.into();
84	self	157	self
@@ -86,6 +159,22 @@ impl Button { · 1 unmodified line
86	}	159	}
87		160
88	impl Selectable for Button {	161	impl Selectable for Button {
		162	/// Sets the selected state of the button.
		163	///
		164	/// This method allows the selection state of the button to be specified.
		165	/// It modifies the button's appearance to reflect its selected state.
		166	///
		167	/// # Examples
		168	///
		169	/// ```
		170	/// Button::new("button_id", "Click me!")
		171	/// .selected(true)
		172	/// .on_click(\|event, cx\| {
		173	/// // Handle click event
		174	/// });
		175	/// ```
		176	///
		177	/// Use [`selected_style`](Button::selected_style) to change the style of the button when it is selected.
89	fn selected(mut self, selected: bool) -> Self {	178	fn selected(mut self, selected: bool) -> Self {
90	self.base = self.base.selected(selected);	179	self.base = self.base.selected(selected);
91	self	180	self
@@ -93,6 +182,19 @@ impl Selectable for Button { · 1 unmodified line
93	}	182	}
94		183
95	impl SelectableButton for Button {	184	impl SelectableButton for Button {
		185	/// Sets the style for the button when selected.
		186	///
		187	/// # Examples
		188	///
		189	/// ```
		190	/// Button::new("button_id", "Click me!")
		191	/// .selected(true)
		192	/// .selected_style(ButtonStyle::Tinted(TintColor::Accent))
		193	/// .on_click(\|event, cx\| {
		194	/// // Handle click event
		195	/// });
		196	/// ```
		197	/// This results in a button with a blue tinted background when selected.
96	fn selected_style(mut self, style: ButtonStyle) -> Self {	198	fn selected_style(mut self, style: ButtonStyle) -> Self {
97	self.base = self.base.selected_style(style);	199	self.base = self.base.selected_style(style);
98	self	200	self
@@ -100,6 +202,22 @@ impl SelectableButton for Button { · 1 unmodified line
100	}	202	}
101		203
102	impl Disableable for Button {	204	impl Disableable for Button {
		205	/// Disables the button.
		206	///
		207	/// This method allows the button to be disabled. When a button is disabled,
		208	/// it doesn't react to user interactions and its appearance is updated to reflect this.
		209	///
		210	/// # Examples
		211	///
		212	/// ```
		213	/// Button::new("button_id", "Click me!")
		214	/// .disabled(true)
		215	/// .on_click(\|event, cx\| {
		216	/// // Handle click event
		217	/// });
		218	/// ```
		219	///
		220	/// This results in a button that is disabled and does not respond to click events.
103	fn disabled(mut self, disabled: bool) -> Self {	221	fn disabled(mut self, disabled: bool) -> Self {
104	self.base = self.base.disabled(disabled);	222	self.base = self.base.disabled(disabled);
105	self	223	self
@@ -107,6 +225,7 @@ impl Disableable for Button { · 1 unmodified line
107	}	225	}
108		226
109	impl Clickable for Button {	227	impl Clickable for Button {
		228	/// Sets the click event handler for the button.
110	fn on_click(	229	fn on_click(
111	mut self,	230	mut self,
112	handler: impl Fn(&gpui::ClickEvent, &mut WindowContext) + 'static,	231	handler: impl Fn(&gpui::ClickEvent, &mut WindowContext) + 'static,
@@ -117,11 +236,40 @@ impl Clickable for Button { · 4 unmodified lines
117	}	236	}
118		237
119	impl FixedWidth for Button {	238	impl FixedWidth for Button {
		239	/// Sets a fixed width for the button.
		240	///
		241	/// This function allows a button to have a fixed width instead of automatically growing or shrinking.
		242	/// Sets a fixed width for the button.
		243	///
		244	/// # Examples
		245	///
		246	/// ```
		247	/// Button::new("button_id", "Click me!")
		248	/// .width(DefiniteLength::Pixels(100))
		249	/// .on_click(\|event, cx\| {
		250	/// // Handle click event
		251	/// });
		252	/// ```
		253	///
		254	/// This sets the button's width to be exactly 100 pixels.
120	fn width(mut self, width: DefiniteLength) -> Self {	255	fn width(mut self, width: DefiniteLength) -> Self {
121	self.base = self.base.width(width);	256	self.base = self.base.width(width);
122	self	257	self
123	}	258	}
124		259
		260	/// Sets the button to occupy the full width of its container.
		261	///
		262	/// # Examples
		263	///
		264	/// ```
		265	/// Button::new("button_id", "Click me!")
		266	/// .full_width()
		267	/// .on_click(\|event, cx\| {
		268	/// // Handle click event
		269	/// });
		270	/// ```
		271	///
		272	/// This stretches the button to the full width of its container.
125	fn full_width(mut self) -> Self {	273	fn full_width(mut self) -> Self {
126	self.base = self.base.full_width();	274	self.base = self.base.full_width();
127	self	275	self
@@ -129,20 +277,42 @@ impl FixedWidth for Button { · 1 unmodified line
129	}	277	}
130		278
131	impl ButtonCommon for Button {	279	impl ButtonCommon for Button {
		280	/// Sets the button's id.
132	fn id(&self) -> &ElementId {	281	fn id(&self) -> &ElementId {
133	self.base.id()	282	self.base.id()
134	}	283	}
135		284
		285	/// Sets the visual style of the button using a [`ButtonStyle`].
136	fn style(mut self, style: ButtonStyle) -> Self {	286	fn style(mut self, style: ButtonStyle) -> Self {
137	self.base = self.base.style(style);	287	self.base = self.base.style(style);
138	self	288	self
139	}	289	}
140		290
		291	/// Sets the button's size using a [`ButtonSize`].
141	fn size(mut self, size: ButtonSize) -> Self {	292	fn size(mut self, size: ButtonSize) -> Self {
142	self.base = self.base.size(size);	293	self.base = self.base.size(size);
143	self	294	self
144	}	295	}
145		296
		297	/// Sets a tooltip for the button.
		298	///
		299	/// This method allows a tooltip to be set for the button. The tooltip is a function that
		300	/// takes a mutable reference to a [`WindowContext`] and returns an [`AnyView`]. The tooltip
		301	/// is displayed when the user hovers over the button.
		302	///
		303	/// # Examples
		304	///
		305	/// ```
		306	/// Button::new("button_id", "Click me!")
		307	/// .tooltip(\|cx\| {
		308	/// Text::new("This is a tooltip").into()
		309	/// })
		310	/// .on_click(\|event, cx\| {
		311	/// // Handle click event
		312	/// });
		313	/// ```
		314	///
		315	/// This will create a button with a tooltip that displays "This is a tooltip" when hovered over.
146	fn tooltip(mut self, tooltip: impl Fn(&mut WindowContext) -> AnyView + 'static) -> Self {	316	fn tooltip(mut self, tooltip: impl Fn(&mut WindowContext) -> AnyView + 'static) -> Self {
147	self.base = self.base.tooltip(tooltip);	317	self.base = self.base.tooltip(tooltip);
148	self	318	self

crates/ui/src/components/button/button_icon.rs+6−6

@@ -1,4 +1,4 @@
1	use crate::{prelude::*, Icon, IconElement, IconSize};	1	use crate::{prelude::*, Icon, IconName, IconSize};
2		2
3	/// An icon that appears within a button.	3	/// An icon that appears within a button.
4	///	4	///
@@ -6,17 +6,17 @@ use crate::{prelude::*, Icon, IconElement, IconSize}; · 1 unmodified line
6	/// or as a standalone icon, like in [`IconButton`](crate::IconButton).	6	/// or as a standalone icon, like in [`IconButton`](crate::IconButton).
7	#[derive(IntoElement)]	7	#[derive(IntoElement)]
8	pub(super) struct ButtonIcon {	8	pub(super) struct ButtonIcon {
9	icon: Icon,	9	icon: IconName,
10	size: IconSize,	10	size: IconSize,
11	color: Color,	11	color: Color,
12	disabled: bool,	12	disabled: bool,
13	selected: bool,	13	selected: bool,
14	selected_icon: Option<Icon>,	14	selected_icon: Option<IconName>,
15	selected_style: Option<ButtonStyle>,	15	selected_style: Option<ButtonStyle>,
16	}	16	}
17		17
18	impl ButtonIcon {	18	impl ButtonIcon {
19	pub fn new(icon: Icon) -> Self {	19	pub fn new(icon: IconName) -> Self {
20	Self {	20	Self {
21	icon,	21	icon,
22	size: IconSize::default(),	22	size: IconSize::default(),
@@ -44,7 +44,7 @@ impl ButtonIcon { · 21 unmodified lines
44	self	44	self
45	}	45	}
46		46
47	pub fn selected_icon(mut self, icon: impl Into<Option<Icon>>) -> Self {	47	pub fn selected_icon(mut self, icon: impl Into<Option<IconName>>) -> Self {
48	self.selected_icon = icon.into();	48	self.selected_icon = icon.into();
49	self	49	self
50	}	50	}
@@ -88,6 +88,6 @@ impl RenderOnce for ButtonIcon { · 37 unmodified lines
88	self.color	88	self.color
89	};	89	};
90		90
91	IconElement::new(icon).size(self.size).color(icon_color)	91	Icon::new(icon).size(self.size).color(icon_color)
92	}	92	}
93	}	93	}

crates/ui/src/components/button/button_like.rs+6−2

 use crate::prelude::*;
+/// A trait for buttons that can be Selected. Enables setting the [`ButtonStyle`] of a button when it is selected.
 pub trait SelectableButton: Selectable {
     fn selected_style(self, style: ButtonStyle) -> Self;
 }
+/// A common set of traits all buttons must implement.
 pub trait ButtonCommon: Clickable + Disableable {
     /// A unique element ID to identify the button.
     fn id(&self) -> &ElementId;
     }
 }
+/// The visual appearance of a button.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Default)]
 pub enum ButtonStyle {
     /// A filled button with a solid background color. Provides emphasis versus
     }
 }
-/// ButtonSize can also be used to help build  non-button elements
+/// The height of a button.
-/// that are consistently sized with buttons.
+///
+/// Can also be used to size non-button elements to align with [`Button`]s.
 #[derive(Default, PartialEq, Clone, Copy)]
 pub enum ButtonSize {
     Large,

crates/ui/src/components/button/icon_button.rs+5−5

@@ -1,21 +1,21 @@
1	use gpui::{AnyView, DefiniteLength};	1	use gpui::{AnyView, DefiniteLength};
2		2
3	use crate::{prelude::*, SelectableButton};	3	use crate::{prelude::*, SelectableButton};
4	use crate::{ButtonCommon, ButtonLike, ButtonSize, ButtonStyle, Icon, IconSize};	4	use crate::{ButtonCommon, ButtonLike, ButtonSize, ButtonStyle, IconName, IconSize};
5		5
6	use super::button_icon::ButtonIcon;	6	use super::button_icon::ButtonIcon;
7		7
8	#[derive(IntoElement)]	8	#[derive(IntoElement)]
9	pub struct IconButton {	9	pub struct IconButton {
10	base: ButtonLike,	10	base: ButtonLike,
11	icon: Icon,	11	icon: IconName,
12	icon_size: IconSize,	12	icon_size: IconSize,
13	icon_color: Color,	13	icon_color: Color,
14	selected_icon: Option<Icon>,	14	selected_icon: Option<IconName>,
15	}	15	}
16		16
17	impl IconButton {	17	impl IconButton {
18	pub fn new(id: impl Into<ElementId>, icon: Icon) -> Self {	18	pub fn new(id: impl Into<ElementId>, icon: IconName) -> Self {
19	Self {	19	Self {
20	base: ButtonLike::new(id),	20	base: ButtonLike::new(id),
21	icon,	21	icon,
@@ -35,7 +35,7 @@ impl IconButton { · 13 unmodified lines
35	self	35	self
36	}	36	}
37		37
38	pub fn selected_icon(mut self, icon: impl Into<Option<Icon>>) -> Self {	38	pub fn selected_icon(mut self, icon: impl Into<Option<IconName>>) -> Self {
39	self.selected_icon = icon.into();	39	self.selected_icon = icon.into();
40	self	40	self
41	}	41	}

crates/ui/src/components/checkbox.rs+3−3

@@ -1,7 +1,7 @@
1	use gpui::{div, prelude::*, ElementId, IntoElement, Styled, WindowContext};	1	use gpui::{div, prelude::*, ElementId, IntoElement, Styled, WindowContext};
2		2
3	use crate::prelude::*;	3	use crate::prelude::*;
4	use crate::{Color, Icon, IconElement, Selection};	4	use crate::{Color, Icon, IconName, Selection};
5		5
6	pub type CheckHandler = Box<dyn Fn(&Selection, &mut WindowContext) + 'static>;	6	pub type CheckHandler = Box<dyn Fn(&Selection, &mut WindowContext) + 'static>;
7		7
@@ -47,7 +47,7 @@ impl RenderOnce for Checkbox { · 39 unmodified lines
47	let group_id = format!("checkbox_group_{:?}", self.id);	47	let group_id = format!("checkbox_group_{:?}", self.id);
48		48
49	let icon = match self.checked {	49	let icon = match self.checked {
50	Selection::Selected => Some(IconElement::new(Icon::Check).size(IconSize::Small).color(	50	Selection::Selected => Some(Icon::new(IconName::Check).size(IconSize::Small).color(
51	if self.disabled {	51	if self.disabled {
52	Color::Disabled	52	Color::Disabled
53	} else {	53	} else {
@@ -55,7 +55,7 @@ impl RenderOnce for Checkbox { · 1 unmodified line
55	},	55	},
56	)),	56	)),
57	Selection::Indeterminate => Some(	57	Selection::Indeterminate => Some(
58	IconElement::new(Icon::Dash)	58	Icon::new(IconName::Dash)
59	.size(IconSize::Small)	59	.size(IconSize::Small)
60	.color(if self.disabled {	60	.color(if self.disabled {
61	Color::Disabled	61	Color::Disabled

crates/ui/src/components/context_menu.rs+5−5

@@ -1,6 +1,6 @@
1	use crate::{	1	use crate::{
2	h_stack, prelude::*, v_stack, Icon, IconElement, KeyBinding, Label, List, ListItem,	2	h_stack, prelude::*, v_stack, Icon, IconName, KeyBinding, Label, List, ListItem, ListSeparator,
3	ListSeparator, ListSubHeader,	3	ListSubHeader,
4	};	4	};
5	use gpui::{	5	use gpui::{
6	px, Action, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView,	6	px, Action, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView,
@@ -14,7 +14,7 @@ enum ContextMenuItem { · 7 unmodified lines
14	Header(SharedString),	14	Header(SharedString),
15	Entry {	15	Entry {
16	label: SharedString,	16	label: SharedString,
17	icon: Option<Icon>,	17	icon: Option<IconName>,
18	handler: Rc<dyn Fn(&mut WindowContext)>,	18	handler: Rc<dyn Fn(&mut WindowContext)>,
19	action: Option<Box<dyn Action>>,	19	action: Option<Box<dyn Action>>,
20	},	20	},
@@ -117,7 +117,7 @@ impl ContextMenu { · 96 unmodified lines
117	label: label.into(),	117	label: label.into(),
118	action: Some(action.boxed_clone()),	118	action: Some(action.boxed_clone()),
119	handler: Rc::new(move \|cx\| cx.dispatch_action(action.boxed_clone())),	119	handler: Rc::new(move \|cx\| cx.dispatch_action(action.boxed_clone())),
120	icon: Some(Icon::Link),	120	icon: Some(IconName::Link),
121	});	121	});
122	self	122	self
123	}	123	}
@@ -280,7 +280,7 @@ impl Render for ContextMenu { · 156 unmodified lines
280	h_stack()	280	h_stack()
281	.gap_1()	281	.gap_1()
282	.child(Label::new(label.clone()))	282	.child(Label::new(label.clone()))
283	.child(IconElement::new(*icon))	283	.child(Icon::new(*icon))
284	.into_any_element()	284	.into_any_element()
285	} else {	285	} else {
286	Label::new(label.clone()).into_any_element()	286	Label::new(label.clone()).into_any_element()

crates/ui/src/components/disclosure.rs+3−3

@@ -1,6 +1,6 @@
1	use gpui::ClickEvent;	1	use gpui::ClickEvent;
2		2
3	use crate::{prelude::*, Color, Icon, IconButton, IconSize};	3	use crate::{prelude::*, Color, IconButton, IconName, IconSize};
4		4
5	#[derive(IntoElement)]	5	#[derive(IntoElement)]
6	pub struct Disclosure {	6	pub struct Disclosure {
@@ -32,8 +32,8 @@ impl RenderOnce for Disclosure { · 25 unmodified lines
32	IconButton::new(	32	IconButton::new(
33	self.id,	33	self.id,
34	match self.is_open {	34	match self.is_open {
35	true => Icon::ChevronDown,	35	true => IconName::ChevronDown,
36	false => Icon::ChevronRight,	36	false => IconName::ChevronRight,
37	},	37	},
38	)	38	)
39	.icon_color(Color::Muted)	39	.icon_color(Color::Muted)

crates/ui/src/components/divider.rs+1−0

@@ -7,6 +7,7 @@ enum DividerDirection { · 6 unmodified lines
7	Vertical,	7	Vertical,
8	}	8	}
9		9
		10	/// The color of a [`Divider`].
10	#[derive(Default)]	11	#[derive(Default)]
11	pub enum DividerColor {	12	pub enum DividerColor {
12	Border,	13	Border,

crates/ui/src/components/icon.rs+101−101

@@ -22,7 +22,7 @@ impl IconSize { · 21 unmodified lines
22	}	22	}
23		23
24	#[derive(Debug, PartialEq, Copy, Clone, EnumIter)]	24	#[derive(Debug, PartialEq, Copy, Clone, EnumIter)]
25	pub enum Icon {	25	pub enum IconName {
26	Ai,	26	Ai,
27	ArrowDown,	27	ArrowDown,
28	ArrowLeft,	28	ArrowLeft,
@@ -111,118 +111,108 @@ pub enum Icon { · 82 unmodified lines
111	ZedXCopilot,	111	ZedXCopilot,
112	}	112	}
113		113
114	impl Icon {	114	impl IconName {
115	pub fn path(self) -> &'static str {	115	pub fn path(self) -> &'static str {
116	match self {	116	match self {
117	Icon::Ai => "icons/ai.svg",	117	IconName::Ai => "icons/ai.svg",
118	Icon::ArrowDown => "icons/arrow_down.svg",	118	IconName::ArrowDown => "icons/arrow_down.svg",
119	Icon::ArrowLeft => "icons/arrow_left.svg",	119	IconName::ArrowLeft => "icons/arrow_left.svg",
120	Icon::ArrowRight => "icons/arrow_right.svg",	120	IconName::ArrowRight => "icons/arrow_right.svg",
121	Icon::ArrowUp => "icons/arrow_up.svg",	121	IconName::ArrowUp => "icons/arrow_up.svg",
122	Icon::ArrowUpRight => "icons/arrow_up_right.svg",	122	IconName::ArrowUpRight => "icons/arrow_up_right.svg",
123	Icon::ArrowCircle => "icons/arrow_circle.svg",	123	IconName::ArrowCircle => "icons/arrow_circle.svg",
124	Icon::AtSign => "icons/at_sign.svg",	124	IconName::AtSign => "icons/at_sign.svg",
125	Icon::AudioOff => "icons/speaker_off.svg",	125	IconName::AudioOff => "icons/speaker_off.svg",
126	Icon::AudioOn => "icons/speaker_loud.svg",	126	IconName::AudioOn => "icons/speaker_loud.svg",
127	Icon::Backspace => "icons/backspace.svg",	127	IconName::Backspace => "icons/backspace.svg",
128	Icon::Bell => "icons/bell.svg",	128	IconName::Bell => "icons/bell.svg",
129	Icon::BellOff => "icons/bell_off.svg",	129	IconName::BellOff => "icons/bell_off.svg",
130	Icon::BellRing => "icons/bell_ring.svg",	130	IconName::BellRing => "icons/bell_ring.svg",
131	Icon::Bolt => "icons/bolt.svg",	131	IconName::Bolt => "icons/bolt.svg",
132	Icon::CaseSensitive => "icons/case_insensitive.svg",	132	IconName::CaseSensitive => "icons/case_insensitive.svg",
133	Icon::Check => "icons/check.svg",	133	IconName::Check => "icons/check.svg",
134	Icon::ChevronDown => "icons/chevron_down.svg",	134	IconName::ChevronDown => "icons/chevron_down.svg",
135	Icon::ChevronLeft => "icons/chevron_left.svg",	135	IconName::ChevronLeft => "icons/chevron_left.svg",
136	Icon::ChevronRight => "icons/chevron_right.svg",	136	IconName::ChevronRight => "icons/chevron_right.svg",
137	Icon::ChevronUp => "icons/chevron_up.svg",	137	IconName::ChevronUp => "icons/chevron_up.svg",
138	Icon::Close => "icons/x.svg",	138	IconName::Close => "icons/x.svg",
139	Icon::Collab => "icons/user_group_16.svg",	139	IconName::Collab => "icons/user_group_16.svg",
140	Icon::Command => "icons/command.svg",	140	IconName::Command => "icons/command.svg",
141	Icon::Control => "icons/control.svg",	141	IconName::Control => "icons/control.svg",
142	Icon::Copilot => "icons/copilot.svg",	142	IconName::Copilot => "icons/copilot.svg",
143	Icon::CopilotDisabled => "icons/copilot_disabled.svg",	143	IconName::CopilotDisabled => "icons/copilot_disabled.svg",
144	Icon::CopilotError => "icons/copilot_error.svg",	144	IconName::CopilotError => "icons/copilot_error.svg",
145	Icon::CopilotInit => "icons/copilot_init.svg",	145	IconName::CopilotInit => "icons/copilot_init.svg",
146	Icon::Copy => "icons/copy.svg",	146	IconName::Copy => "icons/copy.svg",
147	Icon::Dash => "icons/dash.svg",	147	IconName::Dash => "icons/dash.svg",
148	Icon::Delete => "icons/delete.svg",	148	IconName::Delete => "icons/delete.svg",
149	Icon::Disconnected => "icons/disconnected.svg",	149	IconName::Disconnected => "icons/disconnected.svg",
150	Icon::Ellipsis => "icons/ellipsis.svg",	150	IconName::Ellipsis => "icons/ellipsis.svg",
151	Icon::Envelope => "icons/feedback.svg",	151	IconName::Envelope => "icons/feedback.svg",
152	Icon::Escape => "icons/escape.svg",	152	IconName::Escape => "icons/escape.svg",
153	Icon::ExclamationTriangle => "icons/warning.svg",	153	IconName::ExclamationTriangle => "icons/warning.svg",
154	Icon::Exit => "icons/exit.svg",	154	IconName::Exit => "icons/exit.svg",
155	Icon::ExternalLink => "icons/external_link.svg",	155	IconName::ExternalLink => "icons/external_link.svg",
156	Icon::File => "icons/file.svg",	156	IconName::File => "icons/file.svg",
157	Icon::FileDoc => "icons/file_icons/book.svg",	157	IconName::FileDoc => "icons/file_icons/book.svg",
158	Icon::FileGeneric => "icons/file_icons/file.svg",	158	IconName::FileGeneric => "icons/file_icons/file.svg",
159	Icon::FileGit => "icons/file_icons/git.svg",	159	IconName::FileGit => "icons/file_icons/git.svg",
160	Icon::FileLock => "icons/file_icons/lock.svg",	160	IconName::FileLock => "icons/file_icons/lock.svg",
161	Icon::FileRust => "icons/file_icons/rust.svg",	161	IconName::FileRust => "icons/file_icons/rust.svg",
162	Icon::FileToml => "icons/file_icons/toml.svg",	162	IconName::FileToml => "icons/file_icons/toml.svg",
163	Icon::FileTree => "icons/project.svg",	163	IconName::FileTree => "icons/project.svg",
164	Icon::Filter => "icons/filter.svg",	164	IconName::Filter => "icons/filter.svg",
165	Icon::Folder => "icons/file_icons/folder.svg",	165	IconName::Folder => "icons/file_icons/folder.svg",
166	Icon::FolderOpen => "icons/file_icons/folder_open.svg",	166	IconName::FolderOpen => "icons/file_icons/folder_open.svg",
167	Icon::FolderX => "icons/stop_sharing.svg",	167	IconName::FolderX => "icons/stop_sharing.svg",
168	Icon::Github => "icons/github.svg",	168	IconName::Github => "icons/github.svg",
169	Icon::Hash => "icons/hash.svg",	169	IconName::Hash => "icons/hash.svg",
170	Icon::InlayHint => "icons/inlay_hint.svg",	170	IconName::InlayHint => "icons/inlay_hint.svg",
171	Icon::Link => "icons/link.svg",	171	IconName::Link => "icons/link.svg",
172	Icon::MagicWand => "icons/magic_wand.svg",	172	IconName::MagicWand => "icons/magic_wand.svg",
173	Icon::MagnifyingGlass => "icons/magnifying_glass.svg",	173	IconName::MagnifyingGlass => "icons/magnifying_glass.svg",
174	Icon::MailOpen => "icons/mail_open.svg",	174	IconName::MailOpen => "icons/mail_open.svg",
175	Icon::Maximize => "icons/maximize.svg",	175	IconName::Maximize => "icons/maximize.svg",
176	Icon::Menu => "icons/menu.svg",	176	IconName::Menu => "icons/menu.svg",
177	Icon::MessageBubbles => "icons/conversations.svg",	177	IconName::MessageBubbles => "icons/conversations.svg",
178	Icon::Mic => "icons/mic.svg",	178	IconName::Mic => "icons/mic.svg",
179	Icon::MicMute => "icons/mic_mute.svg",	179	IconName::MicMute => "icons/mic_mute.svg",
180	Icon::Minimize => "icons/minimize.svg",	180	IconName::Minimize => "icons/minimize.svg",
181	Icon::Option => "icons/option.svg",	181	IconName::Option => "icons/option.svg",
182	Icon::PageDown => "icons/page_down.svg",	182	IconName::PageDown => "icons/page_down.svg",
183	Icon::PageUp => "icons/page_up.svg",	183	IconName::PageUp => "icons/page_up.svg",
184	Icon::Plus => "icons/plus.svg",	184	IconName::Plus => "icons/plus.svg",
185	Icon::Public => "icons/public.svg",	185	IconName::Public => "icons/public.svg",
186	Icon::Quote => "icons/quote.svg",	186	IconName::Quote => "icons/quote.svg",
187	Icon::Replace => "icons/replace.svg",	187	IconName::Replace => "icons/replace.svg",
188	Icon::ReplaceAll => "icons/replace_all.svg",	188	IconName::ReplaceAll => "icons/replace_all.svg",
189	Icon::ReplaceNext => "icons/replace_next.svg",	189	IconName::ReplaceNext => "icons/replace_next.svg",
190	Icon::Return => "icons/return.svg",	190	IconName::Return => "icons/return.svg",
191	Icon::Screen => "icons/desktop.svg",	191	IconName::Screen => "icons/desktop.svg",
192	Icon::SelectAll => "icons/select_all.svg",	192	IconName::SelectAll => "icons/select_all.svg",
193	Icon::Shift => "icons/shift.svg",	193	IconName::Shift => "icons/shift.svg",
194	Icon::Snip => "icons/snip.svg",	194	IconName::Snip => "icons/snip.svg",
195	Icon::Space => "icons/space.svg",	195	IconName::Space => "icons/space.svg",
196	Icon::Split => "icons/split.svg",	196	IconName::Split => "icons/split.svg",
197	Icon::Tab => "icons/tab.svg",	197	IconName::Tab => "icons/tab.svg",
198	Icon::Terminal => "icons/terminal.svg",	198	IconName::Terminal => "icons/terminal.svg",
199	Icon::Update => "icons/update.svg",	199	IconName::Update => "icons/update.svg",
200	Icon::WholeWord => "icons/word_search.svg",	200	IconName::WholeWord => "icons/word_search.svg",
201	Icon::XCircle => "icons/error.svg",	201	IconName::XCircle => "icons/error.svg",
202	Icon::ZedXCopilot => "icons/zed_x_copilot.svg",	202	IconName::ZedXCopilot => "icons/zed_x_copilot.svg",
203	}	203	}
204	}	204	}
205	}	205	}
206		206
207	#[derive(IntoElement)]	207	#[derive(IntoElement)]
208	pub struct IconElement {	208	pub struct Icon {
209	path: SharedString,	209	path: SharedString,
210	color: Color,	210	color: Color,
211	size: IconSize,	211	size: IconSize,
212	}	212	}
213		213
214	impl RenderOnce for IconElement {	214	impl Icon {
215	fn render(self, cx: &mut WindowContext) -> impl IntoElement {	215	pub fn new(icon: IconName) -> Self {
216	svg()
217	.size(self.size.rems())
218	.flex_none()
219	.path(self.path)
220	.text_color(self.color.color(cx))
221	}
222	}
223
224	impl IconElement {
225	pub fn new(icon: Icon) -> Self {
226	Self {	216	Self {
227	path: icon.path().into(),	217	path: icon.path().into(),
228	color: Color::default(),	218	color: Color::default(),
@@ -248,3 +238,13 @@ impl IconElement { · 19 unmodified lines
248	self	238	self
249	}	239	}
250	}	240	}
		241
		242	impl RenderOnce for Icon {
		243	fn render(self, cx: &mut WindowContext) -> impl IntoElement {
		244	svg()
		245	.size(self.size.rems())
		246	.flex_none()
		247	.path(self.path)
		248	.text_color(self.color.color(cx))
		249	}
		250	}

crates/ui/src/components/keybinding.rs+22−22

@@ -1,4 +1,4 @@
1	use crate::{h_stack, prelude::*, Icon, IconElement, IconSize};	1	use crate::{h_stack, prelude::*, Icon, IconName, IconSize};
2	use gpui::{relative, rems, Action, FocusHandle, IntoElement, Keystroke};	2	use gpui::{relative, rems, Action, FocusHandle, IntoElement, Keystroke};
3		3
4	#[derive(IntoElement, Clone)]	4	#[derive(IntoElement, Clone)]
@@ -26,16 +26,16 @@ impl RenderOnce for KeyBinding { · 21 unmodified lines
26	.text_color(cx.theme().colors().text_muted)	26	.text_color(cx.theme().colors().text_muted)
27	.when(keystroke.modifiers.function, \|el\| el.child(Key::new("fn")))	27	.when(keystroke.modifiers.function, \|el\| el.child(Key::new("fn")))
28	.when(keystroke.modifiers.control, \|el\| {	28	.when(keystroke.modifiers.control, \|el\| {
29	el.child(KeyIcon::new(Icon::Control))	29	el.child(KeyIcon::new(IconName::Control))
30	})	30	})
31	.when(keystroke.modifiers.alt, \|el\| {	31	.when(keystroke.modifiers.alt, \|el\| {
32	el.child(KeyIcon::new(Icon::Option))	32	el.child(KeyIcon::new(IconName::Option))
33	})	33	})
34	.when(keystroke.modifiers.command, \|el\| {	34	.when(keystroke.modifiers.command, \|el\| {
35	el.child(KeyIcon::new(Icon::Command))	35	el.child(KeyIcon::new(IconName::Command))
36	})	36	})
37	.when(keystroke.modifiers.shift, \|el\| {	37	.when(keystroke.modifiers.shift, \|el\| {
38	el.child(KeyIcon::new(Icon::Shift))	38	el.child(KeyIcon::new(IconName::Shift))
39	})	39	})
40	.when_some(key_icon, \|el, icon\| el.child(KeyIcon::new(icon)))	40	.when_some(key_icon, \|el, icon\| el.child(KeyIcon::new(icon)))
41	.when(key_icon.is_none(), \|el\| {	41	.when(key_icon.is_none(), \|el\| {
@@ -62,21 +62,21 @@ impl KeyBinding { · 20 unmodified lines
62	Some(Self::new(key_binding))	62	Some(Self::new(key_binding))
63	}	63	}
64		64
65	fn icon_for_key(keystroke: &Keystroke) -> Option<Icon> {	65	fn icon_for_key(keystroke: &Keystroke) -> Option<IconName> {
66	match keystroke.key.as_str() {	66	match keystroke.key.as_str() {
67	"left" => Some(Icon::ArrowLeft),	67	"left" => Some(IconName::ArrowLeft),
68	"right" => Some(Icon::ArrowRight),	68	"right" => Some(IconName::ArrowRight),
69	"up" => Some(Icon::ArrowUp),	69	"up" => Some(IconName::ArrowUp),
70	"down" => Some(Icon::ArrowDown),	70	"down" => Some(IconName::ArrowDown),
71	"backspace" => Some(Icon::Backspace),	71	"backspace" => Some(IconName::Backspace),
72	"delete" => Some(Icon::Delete),	72	"delete" => Some(IconName::Delete),
73	"return" => Some(Icon::Return),	73	"return" => Some(IconName::Return),
74	"enter" => Some(Icon::Return),	74	"enter" => Some(IconName::Return),
75	"tab" => Some(Icon::Tab),	75	"tab" => Some(IconName::Tab),
76	"space" => Some(Icon::Space),	76	"space" => Some(IconName::Space),
77	"escape" => Some(Icon::Escape),	77	"escape" => Some(IconName::Escape),
78	"pagedown" => Some(Icon::PageDown),	78	"pagedown" => Some(IconName::PageDown),
79	"pageup" => Some(Icon::PageUp),	79	"pageup" => Some(IconName::PageUp),
80	_ => None,	80	_ => None,
81	}	81	}
82	}	82	}
@@ -120,13 +120,13 @@ impl Key { · 37 unmodified lines
120		120
121	#[derive(IntoElement)]	121	#[derive(IntoElement)]
122	pub struct KeyIcon {	122	pub struct KeyIcon {
123	icon: Icon,	123	icon: IconName,
124	}	124	}
125		125
126	impl RenderOnce for KeyIcon {	126	impl RenderOnce for KeyIcon {
127	fn render(self, _cx: &mut WindowContext) -> impl IntoElement {	127	fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
128	div().w(rems(14. / 16.)).child(	128	div().w(rems(14. / 16.)).child(
129	IconElement::new(self.icon)	129	Icon::new(self.icon)
130	.size(IconSize::Small)	130	.size(IconSize::Small)
131	.color(Color::Muted),	131	.color(Color::Muted),
132	)	132	)
@@ -134,7 +134,7 @@ impl RenderOnce for KeyIcon { · 1 unmodified line
134	}	134	}
135		135
136	impl KeyIcon {	136	impl KeyIcon {
137	pub fn new(icon: Icon) -> Self {	137	pub fn new(icon: IconName) -> Self {
138	Self { icon }	138	Self { icon }
139	}	139	}
140	}	140	}

crates/ui/src/components/label/label.rs+57−0

@@ -2,6 +2,28 @@ use gpui::WindowContext; · 1 unmodified line
2		2
3	use crate::{prelude::*, LabelCommon, LabelLike, LabelSize, LineHeightStyle};	3	use crate::{prelude::*, LabelCommon, LabelLike, LabelSize, LineHeightStyle};
4		4
		5	/// A struct representing a label element in the UI.
		6	///
		7	/// The `Label` struct stores the label text and common properties for a label element.
		8	/// It provides methods for modifying these properties.
		9	///
		10	/// # Examples
		11	///
		12	/// ```
		13	/// Label::new("Hello, World!")
		14	/// ```
		15	///
		16	/// A colored label, for example labeling a dangerous action:
		17	///
		18	/// ```
		19	/// let my_label = Label::new("Delete").color(Color::Error);
		20	/// ```
		21	///
		22	/// A label with a strikethrough, for example labeling something that has been deleted:
		23	///
		24	/// ```
		25	/// let my_label = Label::new("Deleted").strikethrough(true);
		26	/// ```
5	#[derive(IntoElement)]	27	#[derive(IntoElement)]
6	pub struct Label {	28	pub struct Label {
7	base: LabelLike,	29	base: LabelLike,
@@ -9,6 +31,13 @@ pub struct Label { · 1 unmodified line
9	}	31	}
10		32
11	impl Label {	33	impl Label {
		34	/// Create a new `Label` with the given text.
		35	///
		36	/// # Examples
		37	///
		38	/// ```
		39	/// let my_label = Label::new("Hello, World!");
		40	/// ```
12	pub fn new(label: impl Into<SharedString>) -> Self {	41	pub fn new(label: impl Into<SharedString>) -> Self {
13	Self {	42	Self {
14	base: LabelLike::new(),	43	base: LabelLike::new(),
@@ -18,21 +47,49 @@ impl Label { · 3 unmodified lines
18	}	47	}
19		48
20	impl LabelCommon for Label {	49	impl LabelCommon for Label {
		50	/// Sets the size of the label using a [`LabelSize`].
		51	///
		52	/// # Examples
		53	///
		54	/// ```
		55	/// let my_label = Label::new("Hello, World!").size(LabelSize::Large);
		56	/// ```
21	fn size(mut self, size: LabelSize) -> Self {	57	fn size(mut self, size: LabelSize) -> Self {
22	self.base = self.base.size(size);	58	self.base = self.base.size(size);
23	self	59	self
24	}	60	}
25		61
		62	/// Sets the line height style of the label using a [`LineHeightStyle`].
		63	///
		64	/// # Examples
		65	///
		66	/// ```
		67	/// let my_label = Label::new("Hello, World!").line_height_style(LineHeightStyle::Normal);
		68	/// ```
26	fn line_height_style(mut self, line_height_style: LineHeightStyle) -> Self {	69	fn line_height_style(mut self, line_height_style: LineHeightStyle) -> Self {
27	self.base = self.base.line_height_style(line_height_style);	70	self.base = self.base.line_height_style(line_height_style);
28	self	71	self
29	}	72	}
30		73
		74	/// Sets the color of the label using a [`Color`].
		75	///
		76	/// # Examples
		77	///
		78	/// ```
		79	/// let my_label = Label::new("Hello, World!").color(Color::Primary);
		80	/// ```
31	fn color(mut self, color: Color) -> Self {	81	fn color(mut self, color: Color) -> Self {
32	self.base = self.base.color(color);	82	self.base = self.base.color(color);
33	self	83	self
34	}	84	}
35		85
		86	/// Sets the strikethrough property of the label.
		87	///
		88	/// # Examples
		89	///
		90	/// ```
		91	/// let my_label = Label::new("Hello, World!").strikethrough(true);
		92	/// ```
36	fn strikethrough(mut self, strikethrough: bool) -> Self {	93	fn strikethrough(mut self, strikethrough: bool) -> Self {
37	self.base = self.base.strikethrough(strikethrough);	94	self.base = self.base.strikethrough(strikethrough);
38	self	95	self

crates/ui/src/components/label/label_like.rs+1−0

@@ -19,6 +19,7 @@ pub enum LineHeightStyle { · 18 unmodified lines
19	UiLabel,	19	UiLabel,
20	}	20	}
21		21
		22	/// A common set of traits all labels must implement.
22	pub trait LabelCommon {	23	pub trait LabelCommon {
23	fn size(self, size: LabelSize) -> Self;	24	fn size(self, size: LabelSize) -> Self;
24	fn line_height_style(self, line_height_style: LineHeightStyle) -> Self;	25	fn line_height_style(self, line_height_style: LineHeightStyle) -> Self;

crates/ui/src/components/list/list_sub_header.rs+7−8

 use crate::prelude::*;
-use crate::{h_stack, Icon, IconElement, IconSize, Label};
+use crate::{h_stack, Icon, IconName, IconSize, Label};
 #[derive(IntoElement)]
 pub struct ListSubHeader {
     label: SharedString,
-    start_slot: Option<Icon>,
+    start_slot: Option<IconName>,
     inset: bool,
 }
         }
     }
-    pub fn left_icon(mut self, left_icon: Option<Icon>) -> Self {
+    pub fn left_icon(mut self, left_icon: Option<IconName>) -> Self {
         self.start_slot = left_icon;
         self
     }
                         .flex()
                         .gap_1()
                         .items_center()
-                        .children(self.start_slot.map(|i| {
+                        .children(
-                            IconElement::new(i)
+                            self.start_slot
-                                .color(Color::Muted)
+                                .map(|i| Icon::new(i).color(Color::Muted).size(IconSize::Small)),
-                                .size(IconSize::Small)
+                        )
-                        }))
                         .child(Label::new(self.label.clone()).color(Color::Muted)),
                 ),
         )

crates/ui/src/components/popover_menu.rs+1−0

@@ -108,6 +108,7 @@ impl<M: ManagedView> PopoverMenu<M> { · 107 unmodified lines
108	}	108	}
109	}	109	}
110		110
		111	/// Creates a [`PopoverMenu`]
111	pub fn popover_menu<M: ManagedView>(id: impl Into<ElementId>) -> PopoverMenu<M> {	112	pub fn popover_menu<M: ManagedView>(id: impl Into<ElementId>) -> PopoverMenu<M> {
112	PopoverMenu {	113	PopoverMenu {
113	id: id.into(),	114	id: id.into(),

crates/ui/src/components/right_click_menu.rs+1−0

@@ -39,6 +39,7 @@ impl<M: ManagedView> RightClickMenu<M> { · 38 unmodified lines
39	}	39	}
40	}	40	}
41		41
		42	/// Creates a [`RightClickMenu`]
42	pub fn right_click_menu<M: ManagedView>(id: impl Into<ElementId>) -> RightClickMenu<M> {	43	pub fn right_click_menu<M: ManagedView>(id: impl Into<ElementId>) -> RightClickMenu<M> {
43	RightClickMenu {	44	RightClickMenu {
44	id: id.into(),	45	id: id.into(),

crates/ui/src/components/stack.rs+2−6

 use crate::StyledExt;
-/// Horizontally stacks elements.
+/// Horizontally stacks elements. Sets `flex()`, `flex_row()`, `items_center()`
-///
-/// Sets `flex()`, `flex_row()`, `items_center()`
 #[track_caller]
 pub fn h_stack() -> Div {
     div().h_flex()
 }
-/// Vertically stacks elements.
+/// Vertically stacks elements. Sets `flex()`, `flex_col()`
-///
-/// Sets `flex()`, `flex_col()`
 #[track_caller]
 pub fn v_stack() -> Div {
     div().v_flex()

crates/ui/src/components/stories/button.rs+3−3

@@ -1,7 +1,7 @@
1	use gpui::Render;	1	use gpui::Render;
2	use story::Story;	2	use story::Story;
3		3
4	use crate::{prelude::*, Icon};	4	use crate::{prelude::*, IconName};
5	use crate::{Button, ButtonStyle};	5	use crate::{Button, ButtonStyle};
6		6
7	pub struct ButtonStory;	7	pub struct ButtonStory;
@@ -23,12 +23,12 @@ impl Render for ButtonStory { · 15 unmodified lines
23	.child(Story::label("With `label_color`"))	23	.child(Story::label("With `label_color`"))
24	.child(Button::new("filled_with_label_color", "Click me").color(Color::Created))	24	.child(Button::new("filled_with_label_color", "Click me").color(Color::Created))
25	.child(Story::label("With `icon`"))	25	.child(Story::label("With `icon`"))
26	.child(Button::new("filled_with_icon", "Click me").icon(Icon::FileGit))	26	.child(Button::new("filled_with_icon", "Click me").icon(IconName::FileGit))
27	.child(Story::label("Selected with `icon`"))	27	.child(Story::label("Selected with `icon`"))
28	.child(	28	.child(
29	Button::new("filled_and_selected_with_icon", "Click me")	29	Button::new("filled_and_selected_with_icon", "Click me")
30	.selected(true)	30	.selected(true)
31	.icon(Icon::FileGit),	31	.icon(IconName::FileGit),
32	)	32	)
33	.child(Story::label("Default (Subtle)"))	33	.child(Story::label("Default (Subtle)"))
34	.child(Button::new("default_subtle", "Click me").style(ButtonStyle::Subtle))	34	.child(Button::new("default_subtle", "Click me").style(ButtonStyle::Subtle))

crates/ui/src/components/stories/icon.rs+4−4

@@ -3,17 +3,17 @@ use story::Story; · 2 unmodified lines
3	use strum::IntoEnumIterator;	3	use strum::IntoEnumIterator;
4		4
5	use crate::prelude::*;	5	use crate::prelude::*;
6	use crate::{Icon, IconElement};	6	use crate::{Icon, IconName};
7		7
8	pub struct IconStory;	8	pub struct IconStory;
9		9
10	impl Render for IconStory {	10	impl Render for IconStory {
11	fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {	11	fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
12	let icons = Icon::iter();	12	let icons = IconName::iter();
13		13
14	Story::container()	14	Story::container()
15	.child(Story::title_for::<IconElement>())	15	.child(Story::title_for::<Icon>())
16	.child(Story::label("All Icons"))	16	.child(Story::label("All Icons"))
17	.child(div().flex().gap_3().children(icons.map(IconElement::new)))	17	.child(div().flex().gap_3().children(icons.map(Icon::new)))
18	}	18	}
19	}	19	}

crates/ui/src/components/stories/icon_button.rs+9−9

@@ -2,7 +2,7 @@ use gpui::Render; · 1 unmodified line
2	use story::{StoryContainer, StoryItem, StorySection};	2	use story::{StoryContainer, StoryItem, StorySection};
3		3
4	use crate::{prelude::*, Tooltip};	4	use crate::{prelude::*, Tooltip};
5	use crate::{Icon, IconButton};	5	use crate::{IconButton, IconName};
6		6
7	pub struct IconButtonStory;	7	pub struct IconButtonStory;
8		8
@@ -10,7 +10,7 @@ impl Render for IconButtonStory { · 1 unmodified line
10	fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {	10	fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
11	let default_button = StoryItem::new(	11	let default_button = StoryItem::new(
12	"Default",	12	"Default",
13	IconButton::new("default_icon_button", Icon::Hash),	13	IconButton::new("default_icon_button", IconName::Hash),
14	)	14	)
15	.description("Displays an icon button.")	15	.description("Displays an icon button.")
16	.usage(	16	.usage(
@@ -21,7 +21,7 @@ impl Render for IconButtonStory { · 4 unmodified lines
21		21
22	let selected_button = StoryItem::new(	22	let selected_button = StoryItem::new(
23	"Selected",	23	"Selected",
24	IconButton::new("selected_icon_button", Icon::Hash).selected(true),	24	IconButton::new("selected_icon_button", IconName::Hash).selected(true),
25	)	25	)
26	.description("Displays an icon button that is selected.")	26	.description("Displays an icon button that is selected.")
27	.usage(	27	.usage(
@@ -32,9 +32,9 @@ impl Render for IconButtonStory { · 4 unmodified lines
32		32
33	let selected_with_selected_icon = StoryItem::new(	33	let selected_with_selected_icon = StoryItem::new(
34	"Selected with `selected_icon`",	34	"Selected with `selected_icon`",
35	IconButton::new("selected_with_selected_icon_button", Icon::AudioOn)	35	IconButton::new("selected_with_selected_icon_button", IconName::AudioOn)
36	.selected(true)	36	.selected(true)
37	.selected_icon(Icon::AudioOff),	37	.selected_icon(IconName::AudioOff),
38	)	38	)
39	.description(	39	.description(
40	"Displays an icon button that is selected and shows a different icon when selected.",	40	"Displays an icon button that is selected and shows a different icon when selected.",
@@ -49,7 +49,7 @@ impl Render for IconButtonStory { · 8 unmodified lines
49		49
50	let disabled_button = StoryItem::new(	50	let disabled_button = StoryItem::new(
51	"Disabled",	51	"Disabled",
52	IconButton::new("disabled_icon_button", Icon::Hash).disabled(true),	52	IconButton::new("disabled_icon_button", IconName::Hash).disabled(true),
53	)	53	)
54	.description("Displays an icon button that is disabled.")	54	.description("Displays an icon button that is disabled.")
55	.usage(	55	.usage(
@@ -60,7 +60,7 @@ impl Render for IconButtonStory { · 4 unmodified lines
60		60
61	let with_on_click_button = StoryItem::new(	61	let with_on_click_button = StoryItem::new(
62	"With `on_click`",	62	"With `on_click`",
63	IconButton::new("with_on_click_button", Icon::Ai).on_click(\|_event, _cx\| {	63	IconButton::new("with_on_click_button", IconName::Ai).on_click(\|_event, _cx\| {
64	println!("Clicked!");	64	println!("Clicked!");
65	}),	65	}),
66	)	66	)
@@ -75,7 +75,7 @@ impl Render for IconButtonStory { · 8 unmodified lines
75		75
76	let with_tooltip_button = StoryItem::new(	76	let with_tooltip_button = StoryItem::new(
77	"With `tooltip`",	77	"With `tooltip`",
78	IconButton::new("with_tooltip_button", Icon::MessageBubbles)	78	IconButton::new("with_tooltip_button", IconName::MessageBubbles)
79	.tooltip(\|cx\| Tooltip::text("Open messages", cx)),	79	.tooltip(\|cx\| Tooltip::text("Open messages", cx)),
80	)	80	)
81	.description("Displays an icon button that has a tooltip when hovered.")	81	.description("Displays an icon button that has a tooltip when hovered.")
@@ -88,7 +88,7 @@ impl Render for IconButtonStory { · 6 unmodified lines
88		88
89	let selected_with_tooltip_button = StoryItem::new(	89	let selected_with_tooltip_button = StoryItem::new(
90	"Selected with `tooltip`",	90	"Selected with `tooltip`",
91	IconButton::new("selected_with_tooltip_button", Icon::InlayHint)	91	IconButton::new("selected_with_tooltip_button", IconName::InlayHint)
92	.selected(true)	92	.selected(true)
93	.tooltip(\|cx\| Tooltip::text("Toggle inlay hints", cx)),	93	.tooltip(\|cx\| Tooltip::text("Toggle inlay hints", cx)),
94	)	94	)

crates/ui/src/components/stories/list_header.rs+7−7

@@ -2,7 +2,7 @@ use gpui::Render; · 1 unmodified line
2	use story::Story;	2	use story::Story;
3		3
4	use crate::{prelude::*, IconButton};	4	use crate::{prelude::*, IconButton};
5	use crate::{Icon, ListHeader};	5	use crate::{IconName, ListHeader};
6		6
7	pub struct ListHeaderStory;	7	pub struct ListHeaderStory;
8		8
@@ -13,19 +13,19 @@ impl Render for ListHeaderStory { · 4 unmodified lines
13	.child(Story::label("Default"))	13	.child(Story::label("Default"))
14	.child(ListHeader::new("Section 1"))	14	.child(ListHeader::new("Section 1"))
15	.child(Story::label("With left icon"))	15	.child(Story::label("With left icon"))
16	.child(ListHeader::new("Section 2").start_slot(IconElement::new(Icon::Bell)))	16	.child(ListHeader::new("Section 2").start_slot(Icon::new(IconName::Bell)))
17	.child(Story::label("With left icon and meta"))	17	.child(Story::label("With left icon and meta"))
18	.child(	18	.child(
19	ListHeader::new("Section 3")	19	ListHeader::new("Section 3")
20	.start_slot(IconElement::new(Icon::BellOff))	20	.start_slot(Icon::new(IconName::BellOff))
21	.end_slot(IconButton::new("action_1", Icon::Bolt)),	21	.end_slot(IconButton::new("action_1", IconName::Bolt)),
22	)	22	)
23	.child(Story::label("With multiple meta"))	23	.child(Story::label("With multiple meta"))
24	.child(	24	.child(
25	ListHeader::new("Section 4")	25	ListHeader::new("Section 4")
26	.end_slot(IconButton::new("action_1", Icon::Bolt))	26	.end_slot(IconButton::new("action_1", IconName::Bolt))
27	.end_slot(IconButton::new("action_2", Icon::ExclamationTriangle))	27	.end_slot(IconButton::new("action_2", IconName::ExclamationTriangle))
28	.end_slot(IconButton::new("action_3", Icon::Plus)),	28	.end_slot(IconButton::new("action_3", IconName::Plus)),
29	)	29	)
30	}	30	}
31	}	31	}

crates/ui/src/components/stories/list_item.rs+13−13

@@ -1,8 +1,8 @@
1	use gpui::Render;	1	use gpui::{Render, SharedUrl};
2	use story::Story;	2	use story::Story;
3		3
4	use crate::{prelude::*, Avatar};	4	use crate::{prelude::*, Avatar};
5	use crate::{Icon, ListItem};	5	use crate::{IconName, ListItem};
6		6
7	pub struct ListItemStory;	7	pub struct ListItemStory;
8		8
@@ -18,13 +18,13 @@ impl Render for ListItemStory { · 9 unmodified lines
18	ListItem::new("inset_list_item")	18	ListItem::new("inset_list_item")
19	.inset(true)	19	.inset(true)
20	.start_slot(	20	.start_slot(
21	IconElement::new(Icon::Bell)	21	Icon::new(IconName::Bell)
22	.size(IconSize::Small)	22	.size(IconSize::Small)
23	.color(Color::Muted),	23	.color(Color::Muted),
24	)	24	)
25	.child("Hello, world!")	25	.child("Hello, world!")
26	.end_slot(	26	.end_slot(
27	IconElement::new(Icon::Bell)	27	Icon::new(IconName::Bell)
28	.size(IconSize::Small)	28	.size(IconSize::Small)
29	.color(Color::Muted),	29	.color(Color::Muted),
30	),	30	),
@@ -34,7 +34,7 @@ impl Render for ListItemStory { · 3 unmodified lines
34	ListItem::new("with start slot_icon")	34	ListItem::new("with start slot_icon")
35	.child("Hello, world!")	35	.child("Hello, world!")
36	.start_slot(	36	.start_slot(
37	IconElement::new(Icon::Bell)	37	Icon::new(IconName::Bell)
38	.size(IconSize::Small)	38	.size(IconSize::Small)
39	.color(Color::Muted),	39	.color(Color::Muted),
40	),	40	),
@@ -43,7 +43,7 @@ impl Render for ListItemStory { · 2 unmodified lines
43	.child(	43	.child(
44	ListItem::new("with_start slot avatar")	44	ListItem::new("with_start slot avatar")
45	.child("Hello, world!")	45	.child("Hello, world!")
46	.start_slot(Avatar::new(SharedString::from(	46	.start_slot(Avatar::new(SharedUrl::from(
47	"https://avatars.githubusercontent.com/u/1714999?v=4",	47	"https://avatars.githubusercontent.com/u/1714999?v=4",
48	))),	48	))),
49	)	49	)
@@ -51,7 +51,7 @@ impl Render for ListItemStory { · 1 unmodified line
51	.child(	51	.child(
52	ListItem::new("with_left_avatar")	52	ListItem::new("with_left_avatar")
53	.child("Hello, world!")	53	.child("Hello, world!")
54	.end_slot(Avatar::new(SharedString::from(	54	.end_slot(Avatar::new(SharedUrl::from(
55	"https://avatars.githubusercontent.com/u/1714999?v=4",	55	"https://avatars.githubusercontent.com/u/1714999?v=4",
56	))),	56	))),
57	)	57	)
@@ -62,23 +62,23 @@ impl Render for ListItemStory { · 4 unmodified lines
62	.end_slot(	62	.end_slot(
63	h_stack()	63	h_stack()
64	.gap_2()	64	.gap_2()
65	.child(Avatar::new(SharedString::from(	65	.child(Avatar::new(SharedUrl::from(
66	"https://avatars.githubusercontent.com/u/1789?v=4",	66	"https://avatars.githubusercontent.com/u/1789?v=4",
67	)))	67	)))
68	.child(Avatar::new(SharedString::from(	68	.child(Avatar::new(SharedUrl::from(
69	"https://avatars.githubusercontent.com/u/1789?v=4",	69	"https://avatars.githubusercontent.com/u/1789?v=4",
70	)))	70	)))
71	.child(Avatar::new(SharedString::from(	71	.child(Avatar::new(SharedUrl::from(
72	"https://avatars.githubusercontent.com/u/1789?v=4",	72	"https://avatars.githubusercontent.com/u/1789?v=4",
73	)))	73	)))
74	.child(Avatar::new(SharedString::from(	74	.child(Avatar::new(SharedUrl::from(
75	"https://avatars.githubusercontent.com/u/1789?v=4",	75	"https://avatars.githubusercontent.com/u/1789?v=4",
76	)))	76	)))
77	.child(Avatar::new(SharedString::from(	77	.child(Avatar::new(SharedUrl::from(
78	"https://avatars.githubusercontent.com/u/1789?v=4",	78	"https://avatars.githubusercontent.com/u/1789?v=4",
79	))),	79	))),
80	)	80	)
81	.end_hover_slot(Avatar::new(SharedString::from(	81	.end_hover_slot(Avatar::new(SharedUrl::from(
82	"https://avatars.githubusercontent.com/u/1714999?v=4",	82	"https://avatars.githubusercontent.com/u/1714999?v=4",
83	))),	83	))),
84	)	84	)

crates/ui/src/components/stories/tab.rs+1−1

@@ -27,7 +27,7 @@ impl Render for TabStory { · 26 unmodified lines
27	h_stack().child(	27	h_stack().child(
28	Tab::new("tab_1")	28	Tab::new("tab_1")
29	.end_slot(	29	.end_slot(
30	IconButton::new("close_button", Icon::Close)	30	IconButton::new("close_button", IconName::Close)
31	.icon_color(Color::Muted)	31	.icon_color(Color::Muted)
32	.size(ButtonSize::None)	32	.size(ButtonSize::None)
33	.icon_size(IconSize::XSmall),	33	.icon_size(IconSize::XSmall),

crates/ui/src/components/stories/tab_bar.rs+7−4

                 h_stack().child(
                     TabBar::new("tab_bar_1")
                         .start_child(
-                            IconButton::new("navigate_backward", Icon::ArrowLeft)
+                            IconButton::new("navigate_backward", IconName::ArrowLeft)
                                 .icon_size(IconSize::Small),
                         )
                         .start_child(
-                            IconButton::new("navigate_forward", Icon::ArrowRight)
+                            IconButton::new("navigate_forward", IconName::ArrowRight)
                                 .icon_size(IconSize::Small),
                         )
-                        .end_child(IconButton::new("new", Icon::Plus).icon_size(IconSize::Small))
                         .end_child(
-                            IconButton::new("split_pane", Icon::Split).icon_size(IconSize::Small),
+                            IconButton::new("new", IconName::Plus).icon_size(IconSize::Small),
+                        )
+                        .end_child(
+                            IconButton::new("split_pane", IconName::Split)
+                                .icon_size(IconSize::Small),
                         )
                         .children(tabs),
                 ),

crates/ui/src/disableable.rs+1−1

@@ -1,4 +1,4 @@
1	/// A trait for elements that can be disabled.	1	/// A trait for elements that can be disabled. Generally used to implement disabling an element's interactivity and changing it's appearance to reflect that it is disabled.
2	pub trait Disableable {	2	pub trait Disableable {
3	/// Sets whether the element is disabled.	3	/// Sets whether the element is disabled.
4	fn disabled(self, disabled: bool) -> Self;	4	fn disabled(self, disabled: bool) -> Self;

crates/ui/src/fixed.rs+1−1

@@ -1,6 +1,6 @@
1	use gpui::DefiniteLength;	1	use gpui::DefiniteLength;
2		2
3	/// A trait for elements that have a fixed with.	3	/// A trait for elements that can have a fixed with. Enables the use of the `width` and `full_width` methods.
4	pub trait FixedWidth {	4	pub trait FixedWidth {
5	/// Sets the width of the element.	5	/// Sets the width of the element.
6	fn width(self, width: DefiniteLength) -> Self;	6	fn width(self, width: DefiniteLength) -> Self;

crates/ui/src/prelude.rs+3−1

+//! The prelude of this crate. When building UI in Zed you almost always want to import this.
 pub use gpui::prelude::*;
 pub use gpui::{
     div, px, relative, rems, AbsoluteLength, DefiniteLength, Div, Element, ElementId,
 pub use crate::{Button, ButtonSize, ButtonStyle, IconButton, SelectableButton};
 pub use crate::{ButtonCommon, Color, StyledExt};
 pub use crate::{Headline, HeadlineSize};
-pub use crate::{Icon, IconElement, IconPosition, IconSize};
+pub use crate::{Icon, IconName, IconPosition, IconSize};
 pub use crate::{Label, LabelCommon, LabelSize, LineHeightStyle};
 pub use theme::ActiveTheme;

crates/ui/src/selectable.rs+9−0

 /// A trait for elements that can be selected.
+///
+/// Generally used to enable "toggle" or "active" behavior and styles on an element through the [`Selection`] status.
 pub trait Selectable {
     /// Sets whether the element is selected.
     fn selected(self, selected: bool) -> Self;
 }
+/// Represents the selection status of an element.
 #[derive(Debug, Default, PartialEq, Eq, Hash, Clone, Copy)]
 pub enum Selection {
+    /// The element is not selected.
     #[default]
     Unselected,
+    /// The selection state of the element is indeterminate.
     Indeterminate,
+    /// The element is selected.
     Selected,
 }
 impl Selection {
+    /// Returns the inverse of the current selection status.
+    ///
+    /// Indeterminate states become selected if inverted.
     pub fn inverse(&self) -> Self {
         match self {
             Self::Unselected | Self::Indeterminate => Self::Selected,

crates/ui/src/styled_ext.rs+14−7

         .shadow(index.shadow())
 }
-/// Extends [`Styled`](gpui::Styled) with Zed specific styling methods.
+/// Extends [`gpui::Styled`] with Zed-specific styling methods.
 pub trait StyledExt: Styled + Sized {
     /// Horizontally stacks elements.
     ///
         self.flex().flex_col()
     }
+    /// Sets the text size using a [`UiTextSize`].
     fn text_ui_size(self, size: UiTextSize) -> Self {
         self.text_size(size.rems())
     }
     ///
     /// Note: The absolute size of this text will change based on a user's `ui_scale` setting.
     ///
-    /// Use [`text_ui_sm`] for regular-sized text.
+    /// Use `text_ui_sm` for smaller text.
     fn text_ui(self) -> Self {
         self.text_size(UiTextSize::default().rems())
     }
     ///
     /// Note: The absolute size of this text will change based on a user's `ui_scale` setting.
     ///
-    /// Use [`text_ui`] for regular-sized text.
+    /// Use `text_ui` for regular-sized text.
     fn text_ui_sm(self) -> Self {
         self.text_size(UiTextSize::Small.rems())
     }
     ///
     /// Note: The absolute size of this text will change based on a user's `ui_scale` setting.
     ///
-    /// Use [`text_ui`] for regular-sized text.
+    /// Use `text_ui` for regular-sized text.
     fn text_ui_xs(self) -> Self {
         self.text_size(UiTextSize::XSmall.rems())
     }
         self.text_size(settings.buffer_font_size(cx))
     }
-    /// The [`Surface`](ui::ElevationIndex::Surface) elevation level, located above the app background, is the standard level for all elements
+    /// The [`Surface`](ElevationIndex::Surface) elevation level, located above the app background, is the standard level for all elements
     ///
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
         elevated(self, cx, ElevationIndex::Surface)
     }
-    /// Non-Modal Elevated Surfaces appear above the [`Surface`](ui::ElevationIndex::Surface) layer and is used for things that should appear above most UI elements like an editor or panel, but not elements like popovers, context menus, modals, etc.
+    /// Non-Modal Elevated Surfaces appear above the [`Surface`](ElevationIndex::Surface) layer and is used for things that should appear above most UI elements like an editor or panel, but not elements like popovers, context menus, modals, etc.
     ///
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
     ///
     /// Elements rendered at this layer should have an enforced behavior: Any interaction outside of the modal will either dismiss the modal or prompt an action (Save your progress, etc) then dismiss the modal.
     ///
-    /// If the element does not have this behavior, it should be rendered at the [`Elevated Surface`](ui::ElevationIndex::ElevatedSurface) layer.
+    /// If the element does not have this behavior, it should be rendered at the [`Elevated Surface`](ElevationIndex::ElevatedSurface) layer.
     ///
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
         self.border_color(cx.theme().colors().border_variant)
     }
+    /// Sets the background color to red for debugging when building UI.
     fn debug_bg_red(self) -> Self {
         self.bg(hsla(0. / 360., 1., 0.5, 1.))
     }
+    /// Sets the background color to green for debugging when building UI.
     fn debug_bg_green(self) -> Self {
         self.bg(hsla(120. / 360., 1., 0.5, 1.))
     }
+    /// Sets the background color to blue for debugging when building UI.
     fn debug_bg_blue(self) -> Self {
         self.bg(hsla(240. / 360., 1., 0.5, 1.))
     }
+    /// Sets the background color to yellow for debugging when building UI.
     fn debug_bg_yellow(self) -> Self {
         self.bg(hsla(60. / 360., 1., 0.5, 1.))
     }
+    /// Sets the background color to cyan for debugging when building UI.
     fn debug_bg_cyan(self) -> Self {
         self.bg(hsla(160. / 360., 1., 0.5, 1.))
     }
+    /// Sets the background color to magenta for debugging when building UI.
     fn debug_bg_magenta(self) -> Self {
         self.bg(hsla(300. / 360., 1., 0.5, 1.))
     }

crates/ui/src/styles/color.rs+1−0

@@ -1,6 +1,7 @@
1	use gpui::{Hsla, WindowContext};	1	use gpui::{Hsla, WindowContext};
2	use theme::ActiveTheme;	2	use theme::ActiveTheme;
3		3
		4	/// Sets a color that has a consistent meaning across all themes.
4	#[derive(Debug, Default, PartialEq, Copy, Clone)]	5	#[derive(Debug, Default, PartialEq, Copy, Clone)]
5	pub enum Color {	6	pub enum Color {
6	#[default]	7	#[default]

crates/ui/src/styles/elevation.rs+1−0

@@ -85,6 +85,7 @@ impl LayerIndex { · 84 unmodified lines
85	}	85	}
86	}	86	}
87		87
		88	/// An appropriate z-index for the given layer based on its intended useage.
88	#[derive(Debug, Clone, Copy, PartialEq, Eq)]	89	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
89	pub enum ElementIndex {	90	pub enum ElementIndex {
90	Effect,	91	Effect,

crates/ui/src/styles/typography.rs+1−0

@@ -38,6 +38,7 @@ impl UiTextSize { · 37 unmodified lines
38	}	38	}
39	}	39	}
40		40
		41	/// The size of a [`Headline`] element
41	#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Default)]	42	#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Default)]
42	pub enum HeadlineSize {	43	pub enum HeadlineSize {
43	XSmall,	44	XSmall,

crates/ui/src/ui.rs+0−2

@@ -3,8 +3,6 @@ · 2 unmodified lines
3	//! This crate provides a set of UI primitives and components that are used to build all of the elements in Zed's UI.	3	//! This crate provides a set of UI primitives and components that are used to build all of the elements in Zed's UI.
4	//!	4	//!
5		5
6	#![doc = include_str!("../docs/building-ui.md")]
7
8	mod clickable;	6	mod clickable;
9	mod components;	7	mod components;
10	mod disableable;	8	mod disableable;

crates/ui/src/utils.rs+2−0

@@ -1,3 +1,5 @@
		1	//! UI-related utilities (e.g. converting dates to a human-readable form).
		2
1	mod format_distance;	3	mod format_distance;
2		4
3	pub use format_distance::*;	5	pub use format_distance::*;

crates/ui/src/utils/format_distance.rs+10−10

@@ -7,10 +7,10 @@ pub enum DateTimeType { · 6 unmodified lines
7	}	7	}
8		8
9	impl DateTimeType {	9	impl DateTimeType {
10	/// Converts the DateTimeType to a NaiveDateTime.	10	/// Converts the [`DateTimeType`] to a [`NaiveDateTime`].
11	///	11	///
12	/// If the DateTimeType is already a NaiveDateTime, it will be returned as is.	12	/// If the [`DateTimeType`] is already a [`NaiveDateTime`], it will be returned as is.
13	/// If the DateTimeType is a DateTime<Local>, it will be converted to a NaiveDateTime.	13	/// If the [`DateTimeType`] is a [`DateTime<Local>`], it will be converted to a [`NaiveDateTime`].
14	pub fn to_naive(&self) -> NaiveDateTime {	14	pub fn to_naive(&self) -> NaiveDateTime {
15	match self {	15	match self {
16	DateTimeType::Naive(naive) => *naive,	16	DateTimeType::Naive(naive) => *naive,
@@ -68,13 +68,13 @@ impl FormatDistance { · 51 unmodified lines
68	}	68	}
69	}	69	}
70		70
71	/// Calculates the distance in seconds between two NaiveDateTime objects.	71	/// Calculates the distance in seconds between two [`NaiveDateTime`] objects.
72	/// It returns a signed integer denoting the difference. If `date` is earlier than `base_date`, the returned value will be negative.	72	/// It returns a signed integer denoting the difference. If `date` is earlier than `base_date`, the returned value will be negative.
73	///	73	///
74	/// ## Arguments	74	/// ## Arguments
75	///	75	///
76	/// * `date` - A NaiveDateTime object representing the date of interest	76	/// * `date` - A [NaiveDateTime`] object representing the date of interest
77	/// * `base_date` - A NaiveDateTime object representing the base date against which the comparison is made	77	/// * `base_date` - A [NaiveDateTime`] object representing the base date against which the comparison is made
78	fn distance_in_seconds(date: NaiveDateTime, base_date: NaiveDateTime) -> i64 {	78	fn distance_in_seconds(date: NaiveDateTime, base_date: NaiveDateTime) -> i64 {
79	let duration = date.signed_duration_since(base_date);	79	let duration = date.signed_duration_since(base_date);
80	-duration.num_seconds()	80	-duration.num_seconds()
@@ -233,12 +233,12 @@ fn distance_string( · 152 unmodified lines
233	///	233	///
234	/// For example, "less than a minute ago", "about 2 hours ago", "3 months from now", etc.	234	/// For example, "less than a minute ago", "about 2 hours ago", "3 months from now", etc.
235	///	235	///
236	/// Use [naive_format_distance_from_now] to compare a NaiveDateTime against now.	236	/// Use [`format_distance_from_now`] to compare a NaiveDateTime against now.
237	///	237	///
238	/// # Arguments	238	/// # Arguments
239	///	239	///
240	/// * `date` - The NaiveDateTime to compare.	240	/// * `date` - The [`NaiveDateTime`] to compare.
241	/// * `base_date` - The NaiveDateTime to compare against.	241	/// * `base_date` - The [`NaiveDateTime`] to compare against.
242	/// * `include_seconds` - A boolean. If true, distances less than a minute are more detailed	242	/// * `include_seconds` - A boolean. If true, distances less than a minute are more detailed
243	/// * `add_suffix` - A boolean. If true, result indicates if the time is in the past or future	243	/// * `add_suffix` - A boolean. If true, result indicates if the time is in the past or future
244	///	244	///
@@ -274,7 +274,7 @@ pub fn format_distance( · 29 unmodified lines
274	///	274	///
275	/// # Arguments	275	/// # Arguments
276	///	276	///
277	/// * `datetime` - The NaiveDateTime to compare with the current time.	277	/// * `datetime` - The [`NaiveDateTime`] to compare with the current time.
278	/// * `include_seconds` - A boolean. If true, distances less than a minute are more detailed	278	/// * `include_seconds` - A boolean. If true, distances less than a minute are more detailed
279	/// * `add_suffix` - A boolean. If true, result indicates if the time is in the past or future	279	/// * `add_suffix` - A boolean. If true, result indicates if the time is in the past or future
280	///	280	///

crates/workspace/src/dock.rs+4−5

     fn set_position(&mut self, position: DockPosition, cx: &mut ViewContext<Self>);
     fn size(&self, cx: &WindowContext) -> Pixels;
     fn set_size(&mut self, size: Option<Pixels>, cx: &mut ViewContext<Self>);
-    fn icon(&self, cx: &WindowContext) -> Option<ui::Icon>;
+    fn icon(&self, cx: &WindowContext) -> Option<ui::IconName>;
     fn icon_tooltip(&self, cx: &WindowContext) -> Option<&'static str>;
     fn toggle_action(&self) -> Box<dyn Action>;
     fn icon_label(&self, _: &WindowContext) -> Option<String> {
     fn set_active(&self, active: bool, cx: &mut WindowContext);
     fn size(&self, cx: &WindowContext) -> Pixels;
     fn set_size(&self, size: Option<Pixels>, cx: &mut WindowContext);
-    fn icon(&self, cx: &WindowContext) -> Option<ui::Icon>;
+    fn icon(&self, cx: &WindowContext) -> Option<ui::IconName>;
     fn icon_tooltip(&self, cx: &WindowContext) -> Option<&'static str>;
     fn toggle_action(&self, cx: &WindowContext) -> Box<dyn Action>;
     fn icon_label(&self, cx: &WindowContext) -> Option<String>;
         self.update(cx, |this, cx| this.set_size(size, cx))
     }
-    fn icon(&self, cx: &WindowContext) -> Option<ui::Icon> {
+    fn icon(&self, cx: &WindowContext) -> Option<ui::IconName> {
         self.read(cx).icon(cx)
     }
                         })
                         .ok();
                 }
-                // todo!() we do not use this event in the production code (even in zed1), remove it
                 PanelEvent::Activate => {
                     if let Some(ix) = this
                         .panel_entries
             self.size = size.unwrap_or(px(300.));
         }
-        fn icon(&self, _: &WindowContext) -> Option<ui::Icon> {
+        fn icon(&self, _: &WindowContext) -> Option<ui::IconName> {
             None
         }

crates/workspace/src/modal_layer.rs+4−0

         let active_modal = self.active_modal.as_ref()?;
         active_modal.modal.view().downcast::<V>().ok()
     }
+    pub fn has_active_modal(&self) -> bool {
+        self.active_modal.is_some()
+    }
 }
 impl Render for ModalLayer {

crates/workspace/src/notifications.rs+2−101

@@ -175,7 +175,7 @@ pub mod simple_message_notification { · 174 unmodified lines
175	};	175	};
176	use std::sync::Arc;	176	use std::sync::Arc;
177	use ui::prelude::*;	177	use ui::prelude::*;
178	use ui::{h_stack, v_stack, Button, Icon, IconElement, Label, StyledExt};	178	use ui::{h_stack, v_stack, Button, Icon, IconName, Label, StyledExt};
179		179
180	pub struct MessageNotification {	180	pub struct MessageNotification {
181	message: SharedString,	181	message: SharedString,
@@ -230,7 +230,7 @@ pub mod simple_message_notification { · 48 unmodified lines
230	.child(	230	.child(
231	div()	231	div()
232	.id("cancel")	232	.id("cancel")
233	.child(IconElement::new(Icon::Close))	233	.child(Icon::new(IconName::Close))
234	.cursor_pointer()	234	.cursor_pointer()
235	.on_click(cx.listener(\|this, _, cx\| this.dismiss(cx))),	235	.on_click(cx.listener(\|this, _, cx\| this.dismiss(cx))),
236	),	236	),
@@ -247,105 +247,6 @@ pub mod simple_message_notification { · 10 unmodified lines
247	}))	247	}))
248	}	248	}
249	}	249	}
250	// todo!()
251	// impl View for MessageNotification {
252	// fn ui_name() -> &'static str {
253	// "MessageNotification"
254	// }
255
256	// fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> gpui::AnyElement<Self> {
257	// let theme = theme::current(cx).clone();
258	// let theme = &theme.simple_message_notification;
259
260	// enum MessageNotificationTag {}
261
262	// let click_message = self.click_message.clone();
263	// let message = match &self.message {
264	// NotificationMessage::Text(text) => {
265	// Text::new(text.to_owned(), theme.message.text.clone()).into_any()
266	// }
267	// NotificationMessage::Element(e) => e(theme.message.text.clone(), cx),
268	// };
269	// let on_click = self.on_click.clone();
270	// let has_click_action = on_click.is_some();
271
272	// Flex::column()
273	// .with_child(
274	// Flex::row()
275	// .with_child(
276	// message
277	// .contained()
278	// .with_style(theme.message.container)
279	// .aligned()
280	// .top()
281	// .left()
282	// .flex(1., true),
283	// )
284	// .with_child(
285	// MouseEventHandler::new::<Cancel, _>(0, cx, \|state, _\| {
286	// let style = theme.dismiss_button.style_for(state);
287	// Svg::new("icons/x.svg")
288	// .with_color(style.color)
289	// .constrained()
290	// .with_width(style.icon_width)
291	// .aligned()
292	// .contained()
293	// .with_style(style.container)
294	// .constrained()
295	// .with_width(style.button_width)
296	// .with_height(style.button_width)
297	// })
298	// .with_padding(Padding::uniform(5.))
299	// .on_click(MouseButton::Left, move \|_, this, cx\| {
300	// this.dismiss(&Default::default(), cx);
301	// })
302	// .with_cursor_style(CursorStyle::PointingHand)
303	// .aligned()
304	// .constrained()
305	// .with_height(cx.font_cache().line_height(theme.message.text.font_size))
306	// .aligned()
307	// .top()
308	// .flex_float(),
309	// ),
310	// )
311	// .with_children({
312	// click_message
313	// .map(\|click_message\| {
314	// MouseEventHandler::new::<MessageNotificationTag, _>(
315	// 0,
316	// cx,
317	// \|state, _\| {
318	// let style = theme.action_message.style_for(state);
319
320	// Flex::row()
321	// .with_child(
322	// Text::new(click_message, style.text.clone())
323	// .contained()
324	// .with_style(style.container),
325	// )
326	// .contained()
327	// },
328	// )
329	// .on_click(MouseButton::Left, move \|_, this, cx\| {
330	// if let Some(on_click) = on_click.as_ref() {
331	// on_click(cx);
332	// this.dismiss(&Default::default(), cx);
333	// }
334	// })
335	// // Since we're not using a proper overlay, we have to capture these extra events
336	// .on_down(MouseButton::Left, \|_, _, _\| {})
337	// .on_up(MouseButton::Left, \|_, _, _\| {})
338	// .with_cursor_style(if has_click_action {
339	// CursorStyle::PointingHand
340	// } else {
341	// CursorStyle::Arrow
342	// })
343	// })
344	// .into_iter()
345	// })
346	// .into_any()
347	// }
348	// }
349	}	250	}
350		251
351	pub trait NotifyResultExt {	252	pub trait NotifyResultExt {

crates/workspace/src/pane.rs+9−9

@@ -31,8 +31,8 @@ use std::{ · 30 unmodified lines
31	use theme::ThemeSettings;	31	use theme::ThemeSettings;
32		32
33	use ui::{	33	use ui::{
34	prelude::*, right_click_menu, ButtonSize, Color, Icon, IconButton, IconSize, Indicator, Label,	34	prelude::*, right_click_menu, ButtonSize, Color, IconButton, IconName, IconSize, Indicator,
35	Tab, TabBar, TabPosition, Tooltip,	35	Label, Tab, TabBar, TabPosition, Tooltip,
36	};	36	};
37	use ui::{v_stack, ContextMenu};	37	use ui::{v_stack, ContextMenu};
38	use util::{maybe, truncate_and_remove_front, ResultExt};	38	use util::{maybe, truncate_and_remove_front, ResultExt};
@@ -384,7 +384,7 @@ impl Pane { · 345 unmodified lines
384	h_stack()	384	h_stack()
385	.gap_2()	385	.gap_2()
386	.child(	386	.child(
387	IconButton::new("plus", Icon::Plus)	387	IconButton::new("plus", IconName::Plus)
388	.icon_size(IconSize::Small)	388	.icon_size(IconSize::Small)
389	.icon_color(Color::Muted)	389	.icon_color(Color::Muted)
390	.on_click(cx.listener(\|pane, _, cx\| {	390	.on_click(cx.listener(\|pane, _, cx\| {
@@ -406,7 +406,7 @@ impl Pane { · 15 unmodified lines
406	el.child(Self::render_menu_overlay(new_item_menu))	406	el.child(Self::render_menu_overlay(new_item_menu))
407	})	407	})
408	.child(	408	.child(
409	IconButton::new("split", Icon::Split)	409	IconButton::new("split", IconName::Split)
410	.icon_size(IconSize::Small)	410	.icon_size(IconSize::Small)
411	.icon_color(Color::Muted)	411	.icon_color(Color::Muted)
412	.on_click(cx.listener(\|pane, _, cx\| {	412	.on_click(cx.listener(\|pane, _, cx\| {
@@ -427,11 +427,11 @@ impl Pane { · 14 unmodified lines
427	)	427	)
428	.child({	428	.child({
429	let zoomed = pane.is_zoomed();	429	let zoomed = pane.is_zoomed();
430	IconButton::new("toggle_zoom", Icon::Maximize)	430	IconButton::new("toggle_zoom", IconName::Maximize)
431	.icon_size(IconSize::Small)	431	.icon_size(IconSize::Small)
432	.icon_color(Color::Muted)	432	.icon_color(Color::Muted)
433	.selected(zoomed)	433	.selected(zoomed)
434	.selected_icon(Icon::Minimize)	434	.selected_icon(IconName::Minimize)
435	.on_click(cx.listener(\|pane, _, cx\| {	435	.on_click(cx.listener(\|pane, _, cx\| {
436	pane.toggle_zoom(&crate::ToggleZoom, cx);	436	pane.toggle_zoom(&crate::ToggleZoom, cx);
437	}))	437	}))
@@ -1570,7 +1570,7 @@ impl Pane { · 1132 unmodified lines
1570	})	1570	})
1571	.start_slot::<Indicator>(indicator)	1571	.start_slot::<Indicator>(indicator)
1572	.end_slot(	1572	.end_slot(
1573	IconButton::new("close tab", Icon::Close)	1573	IconButton::new("close tab", IconName::Close)
1574	.icon_color(Color::Muted)	1574	.icon_color(Color::Muted)
1575	.size(ButtonSize::None)	1575	.size(ButtonSize::None)
1576	.icon_size(IconSize::XSmall)	1576	.icon_size(IconSize::XSmall)
@@ -1676,7 +1676,7 @@ impl Pane { · 99 unmodified lines
1676	h_stack()	1676	h_stack()
1677	.gap_2()	1677	.gap_2()
1678	.child(	1678	.child(
1679	IconButton::new("navigate_backward", Icon::ArrowLeft)	1679	IconButton::new("navigate_backward", IconName::ArrowLeft)
1680	.icon_size(IconSize::Small)	1680	.icon_size(IconSize::Small)
1681	.on_click({	1681	.on_click({
1682	let view = cx.view().clone();	1682	let view = cx.view().clone();
@@ -1686,7 +1686,7 @@ impl Pane { · 3 unmodified lines
1686	.tooltip(\|cx\| Tooltip::for_action("Go Back", &GoBack, cx)),	1686	.tooltip(\|cx\| Tooltip::for_action("Go Back", &GoBack, cx)),
1687	)	1687	)
1688	.child(	1688	.child(
1689	IconButton::new("navigate_forward", Icon::ArrowRight)	1689	IconButton::new("navigate_forward", IconName::ArrowRight)
1690	.icon_size(IconSize::Small)	1690	.icon_size(IconSize::Small)
1691	.on_click({	1691	.on_click({
1692	let view = cx.view().clone();	1692	let view = cx.view().clone();

crates/workspace/src/pane_group.rs+46−22

@@ -12,7 +12,7 @@ use serde::Deserialize; · 11 unmodified lines
12	use std::sync::Arc;	12	use std::sync::Arc;
13	use ui::{prelude::*, Button};	13	use ui::{prelude::*, Button};
14		14
15	const HANDLE_HITBOX_SIZE: f32 = 10.0; //todo!(change this back to 4)	15	const HANDLE_HITBOX_SIZE: f32 = 4.0;
16	const HORIZONTAL_MIN_SIZE: f32 = 80.;	16	const HORIZONTAL_MIN_SIZE: f32 = 80.;
17	const VERTICAL_MIN_SIZE: f32 = 100.;	17	const VERTICAL_MIN_SIZE: f32 = 100.;
18		18
@@ -579,12 +579,15 @@ mod element { · 560 unmodified lines
579	Size, Style, WeakView, WindowContext,	579	Size, Style, WeakView, WindowContext,
580	};	580	};
581	use parking_lot::Mutex;	581	use parking_lot::Mutex;
		582	use settings::Settings;
582	use smallvec::SmallVec;	583	use smallvec::SmallVec;
583	use ui::prelude::*;	584	use ui::prelude::*;
584	use util::ResultExt;	585	use util::ResultExt;
585		586
586	use crate::Workspace;	587	use crate::Workspace;
587		588
		589	use crate::WorkspaceSettings;
		590
588	use super::{HANDLE_HITBOX_SIZE, HORIZONTAL_MIN_SIZE, VERTICAL_MIN_SIZE};	591	use super::{HANDLE_HITBOX_SIZE, HORIZONTAL_MIN_SIZE, VERTICAL_MIN_SIZE};
589		592
590	const DIVIDER_SIZE: f32 = 1.0;	593	const DIVIDER_SIZE: f32 = 1.0;
@@ -704,7 +707,6 @@ mod element { · 113 unmodified lines
704	proposed_current_pixel_change -= current_pixel_change;	707	proposed_current_pixel_change -= current_pixel_change;
705	}	708	}
706		709
707	// todo!(schedule serialize)
708	workspace	710	workspace
709	.update(cx, \|this, cx\| this.schedule_serialize(cx))	711	.update(cx, \|this, cx\| this.schedule_serialize(cx))
710	.log_err();	712	.log_err();
@@ -834,20 +836,39 @@ mod element { · 123 unmodified lines
834	debug_assert!(flexes.len() == len);	836	debug_assert!(flexes.len() == len);
835	debug_assert!(flex_values_in_bounds(flexes.as_slice()));	837	debug_assert!(flex_values_in_bounds(flexes.as_slice()));
836		838
		839	let magnification_value = WorkspaceSettings::get(None, cx).active_pane_magnification;
		840	let active_pane_magnification = if magnification_value == 1. {
		841	None
		842	} else {
		843	Some(magnification_value)
		844	};
		845
		846	let total_flex = if let Some(flex) = active_pane_magnification {
		847	self.children.len() as f32 - 1. + flex
		848	} else {
		849	len as f32
		850	};
		851
837	let mut origin = bounds.origin;	852	let mut origin = bounds.origin;
838	let space_per_flex = bounds.size.along(self.axis) / len as f32;	853	let space_per_flex = bounds.size.along(self.axis) / total_flex;
839		854
840	let mut bounding_boxes = self.bounding_boxes.lock();	855	let mut bounding_boxes = self.bounding_boxes.lock();
841	bounding_boxes.clear();	856	bounding_boxes.clear();
842		857
843	for (ix, child) in self.children.iter_mut().enumerate() {	858	for (ix, child) in self.children.iter_mut().enumerate() {
844	//todo!(active_pane_magnification)	859	let child_flex = active_pane_magnification
845	// If using active pane magnification, need to switch to using	860	.map(\|magnification\| {
846	// 1 for all non-active panes, and then the magnification for the	861	if self.active_pane_ix == Some(ix) {
847	// active pane.	862	magnification
		863	} else {
		864	1.
		865	}
		866	})
		867	.unwrap_or_else(\|\| flexes[ix]);
		868
848	let child_size = bounds	869	let child_size = bounds
849	.size	870	.size
850	.apply_along(self.axis, \|_\| space_per_flex * flexes[ix]);	871	.apply_along(self.axis, \|_\| space_per_flex * child_flex);
851		872
852	let child_bounds = Bounds {	873	let child_bounds = Bounds {
853	origin,	874	origin,
@@ -857,20 +878,23 @@ mod element { · 3 unmodified lines
857	cx.with_z_index(0, \|cx\| {	878	cx.with_z_index(0, \|cx\| {
858	child.draw(origin, child_size.into(), cx);	879	child.draw(origin, child_size.into(), cx);
859	});	880	});
860	cx.with_z_index(1, \|cx\| {	881
861	if ix < len - 1 {	882	if active_pane_magnification.is_none() {
862	Self::push_handle(	883	cx.with_z_index(1, \|cx\| {
863	self.flexes.clone(),	884	if ix < len - 1 {
864	state.clone(),	885	Self::push_handle(
865	self.axis,	886	self.flexes.clone(),
866	ix,	887	state.clone(),
867	child_bounds,	888	self.axis,
868	bounds,	889	ix,
869	self.workspace.clone(),	890	child_bounds,
870	cx,	891	bounds,
871	);	892	self.workspace.clone(),
872	}	893	cx,
873	});	894	);
		895	}
		896	});
		897	}
874		898
875	origin = origin.apply_along(self.axis, \|val\| val + child_size.along(self.axis));	899	origin = origin.apply_along(self.axis, \|val\| val + child_size.along(self.axis));
876	}	900	}

crates/workspace/src/shared_screen.rs+2−2

@@ -12,7 +12,7 @@ use gpui::{ · 11 unmodified lines
12	WindowContext,	12	WindowContext,
13	};	13	};
14	use std::sync::{Arc, Weak};	14	use std::sync::{Arc, Weak};
15	use ui::{h_stack, prelude::*, Icon, IconElement, Label};	15	use ui::{h_stack, prelude::*, Icon, IconName, Label};
16		16
17	pub enum Event {	17	pub enum Event {
18	Close,	18	Close,
@@ -100,7 +100,7 @@ impl Item for SharedScreen { · 81 unmodified lines
100	) -> gpui::AnyElement {	100	) -> gpui::AnyElement {
101	h_stack()	101	h_stack()
102	.gap_1()	102	.gap_1()
103	.child(IconElement::new(Icon::Screen))	103	.child(Icon::new(IconName::Screen))
104	.child(	104	.child(
105	Label::new(format!("{}'s screen", self.user.github_login)).color(if selected {	105	Label::new(format!("{}'s screen", self.user.github_login)).color(if selected {
106	Color::Default	106	Color::Default

crates/workspace/src/toolbar.rs+0−83

@@ -133,82 +133,6 @@ impl Render for Toolbar { · 132 unmodified lines
133	}	133	}
134	}	134	}
135		135
136	// todo!()
137	// impl View for Toolbar {
138	// fn ui_name() -> &'static str {
139	// "Toolbar"
140	// }
141
142	// fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
143	// let theme = &theme::current(cx).workspace.toolbar;
144
145	// let mut primary_left_items = Vec::new();
146	// let mut primary_right_items = Vec::new();
147	// let mut secondary_item = None;
148	// let spacing = theme.item_spacing;
149	// let mut primary_items_row_count = 1;
150
151	// for (item, position) in &self.items {
152	// match *position {
153	// ToolbarItemLocation::Hidden => {}
154
155	// ToolbarItemLocation::PrimaryLeft { flex } => {
156	// primary_items_row_count = primary_items_row_count.max(item.row_count(cx));
157	// let left_item = ChildView::new(item.as_any(), cx).aligned();
158	// if let Some((flex, expanded)) = flex {
159	// primary_left_items.push(left_item.flex(flex, expanded).into_any());
160	// } else {
161	// primary_left_items.push(left_item.into_any());
162	// }
163	// }
164
165	// ToolbarItemLocation::PrimaryRight { flex } => {
166	// primary_items_row_count = primary_items_row_count.max(item.row_count(cx));
167	// let right_item = ChildView::new(item.as_any(), cx).aligned().flex_float();
168	// if let Some((flex, expanded)) = flex {
169	// primary_right_items.push(right_item.flex(flex, expanded).into_any());
170	// } else {
171	// primary_right_items.push(right_item.into_any());
172	// }
173	// }
174
175	// ToolbarItemLocation::Secondary => {
176	// secondary_item = Some(
177	// ChildView::new(item.as_any(), cx)
178	// .constrained()
179	// .with_height(theme.height * item.row_count(cx) as f32)
180	// .into_any(),
181	// );
182	// }
183	// }
184	// }
185
186	// let container_style = theme.container;
187	// let height = theme.height * primary_items_row_count as f32;
188
189	// let mut primary_items = Flex::row().with_spacing(spacing);
190	// primary_items.extend(primary_left_items);
191	// primary_items.extend(primary_right_items);
192
193	// let mut toolbar = Flex::column();
194	// if !primary_items.is_empty() {
195	// toolbar.add_child(primary_items.constrained().with_height(height));
196	// }
197	// if let Some(secondary_item) = secondary_item {
198	// toolbar.add_child(secondary_item);
199	// }
200
201	// if toolbar.is_empty() {
202	// toolbar.into_any_named("toolbar")
203	// } else {
204	// toolbar
205	// .contained()
206	// .with_style(container_style)
207	// .into_any_named("toolbar")
208	// }
209	// }
210	// }
211
212	impl Toolbar {	136	impl Toolbar {
213	pub fn new() -> Self {	137	pub fn new() -> Self {
214	Self {	138	Self {
@@ -312,10 +236,3 @@ impl<T: ToolbarItemView> ToolbarItemViewHandle for View<T> { · 97 unmodified lines
312	self.read(cx).row_count(cx)	236	self.read(cx).row_count(cx)
313	}	237	}
314	}	238	}
315
316	// todo!()
317	// impl From<&dyn ToolbarItemViewHandle> for AnyViewHandle {
318	// fn from(val: &dyn ToolbarItemViewHandle) -> Self {
319	// val.as_any().clone()
320	// }
321	// }

crates/workspace/src/workspace.rs+7−6

         cx: &mut ViewContext<Workspace>,
     ) -> Task<Result<()>> {
         let to_load = if let Some(pane) = pane.upgrade() {
-            // todo!("focus")
-            // cx.focus(&pane);
             pane.update(cx, |pane, cx| {
+                pane.focus(cx);
                 loop {
                     // Retrieve the weak item handle from the history.
                     let entry = pane.nav_history_mut().pop(mode, cx)?;
             });
         }
-        // todo!("focus")
+        cx.focus_self();
-        // cx.focus_self();
         cx.notify();
         self.serialize_workspace(cx);
     }
         cx.notify();
     }
+    // todo!()
     //     #[cfg(any(test, feature = "test-support"))]
     //     pub fn zoomed_view(&self, cx: &AppContext) -> Option<AnyViewHandle> {
     //         self.zoomed.and_then(|view| view.upgrade(cx))
         cx.notify();
     }
-    #[allow(unused)]
     fn schedule_serialize(&mut self, cx: &mut ViewContext<Self>) {
         self._schedule_serialize = Some(cx.spawn(|this, mut cx| async move {
             cx.background_executor()
         div
     }
+    pub fn has_active_modal(&self, cx: &WindowContext<'_>) -> bool {
+        self.modal_layer.read(cx).has_active_modal()
+    }
     pub fn active_modal<V: ManagedView + 'static>(
         &mut self,
         cx: &ViewContext<Self>,

crates/zed/src/zed.rs+0−1

@@ -764,7 +764,6 @@ fn open_bundled_file( · 763 unmodified lines
764	.detach_and_log_err(cx);	764	.detach_and_log_err(cx);
765	}	765	}
766		766
767	// todo!()
768	#[cfg(test)]	767	#[cfg(test)]
769	mod tests {	768	mod tests {
770	use super::*;	769	use super::*;

@@ -31,14 +31,14 @@ pub trait IntoElement: Sized { · 30 unmodified lines
31	/// The specific type of element into which the implementing type is converted.	31	/// The specific type of element into which the implementing type is converted.
32	type Element: Element;	32	type Element: Element;
33		33
34	/// The [ElementId] of self once converted into an [Element].	34	/// The [`ElementId`] of self once converted into an [`Element`].
35	/// If present, the resulting element's state will be carried across frames.	35	/// If present, the resulting element's state will be carried across frames.
36	fn element_id(&self) -> Option<ElementId>;	36	fn element_id(&self) -> Option<ElementId>;
37		37
38	/// Convert self into a type that implements [Element].	38	/// Convert self into a type that implements [`Element`].
39	fn into_element(self) -> Self::Element;	39	fn into_element(self) -> Self::Element;
40		40
41	/// Convert self into a dynamically-typed [AnyElement].	41	/// Convert self into a dynamically-typed [`AnyElement`].
42	fn into_any_element(self) -> AnyElement {	42	fn into_any_element(self) -> AnyElement {
43	self.into_element().into_any()	43	self.into_element().into_any()
44	}	44	}
@@ -115,7 +115,7 @@ pub trait Render: 'static + Sized { · 70 unmodified lines
115	fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement;	115	fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement;
116	}	116	}
117		117
118	/// You can derive [IntoElement] on any type that implements this trait.	118	/// You can derive [`IntoElement`] on any type that implements this trait.
119	/// It is used to allow views to be expressed in terms of abstract data.	119	/// It is used to allow views to be expressed in terms of abstract data.
120	pub trait RenderOnce: 'static {	120	pub trait RenderOnce: 'static {
121	fn render(self, cx: &mut WindowContext) -> impl IntoElement;	121	fn render(self, cx: &mut WindowContext) -> impl IntoElement;
@@ -224,7 +224,7 @@ enum ElementDrawPhase<S> { · 102 unmodified lines
224	},	224	},
225	}	225	}
226		226
227	/// A wrapper around an implementer of [Element] that allows it to be drawn in a window.	227	/// A wrapper around an implementer of [`Element`] that allows it to be drawn in a window.
228	impl<E: Element> DrawableElement<E> {	228	impl<E: Element> DrawableElement<E> {
229	fn new(element: E) -> Self {	229	fn new(element: E) -> Self {
230	DrawableElement {	230	DrawableElement {